Introduction

Version: v5.1.13 Updated: Aug 02, 2024

This documentation aims to provide all the information you need to work with our API.

Base URL

http://localhost/api/v1

Authenticating requests

To authenticate requests, include an Authorization header with the value "Bearer {accessToken}".

All authenticated endpoints are marked with a requires authentication badge in the documentation below.

You can retrieve your token with api Generate API token.

Activity Point

App name: Activity Point Version: 5.1.11 Author: phpFox Updated at: Aug 02, 2024

Browse item

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/harum/activitypoint/conversion-request" \
    --header "Content-Type: application/json" \
    --data "{
    "status": "nihil",
    "from_date": "aspernatur",
    "to_date": "animi",
    "limit": 16,
    "id": 5
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/harum/activitypoint/conversion-request',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'status' => 'nihil',
            'from_date' => 'aspernatur',
            'to_date' => 'animi',
            'limit' => 16,
            'id' => 5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/harum/activitypoint/conversion-request"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "status": "nihil",
    "from_date": "aspernatur",
    "to_date": "animi",
    "limit": 16,
    "id": 5
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/activitypoint/conversion-request

URL Parameters

ver string

Body Parameters

status string optional

from_date string optional

to_date string optional

limit integer optional

Must be at least 1. Must not be greater than 100.

id integer optional

GET api/{ver}/activitypoint/conversion-request/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aut/activitypoint/conversion-request/9405634"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/aut/activitypoint/conversion-request/9405634');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/activitypoint/conversion-request/9405634"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/activitypoint/conversion-request/{id}/cancel

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/facilis/activitypoint/conversion-request/1/cancel"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/facilis/activitypoint/conversion-request/1/cancel');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/facilis/activitypoint/conversion-request/1/cancel"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quis/activitypoint/package?q=fuga" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "aut",
    "sort": "most_viewed",
    "sort_type": "asc",
    "page": 63,
    "limit": 11
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quis/activitypoint/package',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'query' => [
            'q'=> 'fuga',
        ],
        'json' => [
            'q' => 'aut',
            'sort' => 'most_viewed',
            'sort_type' => 'asc',
            'page' => 63,
            'limit' => 11,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quis/activitypoint/package"
);

const params = {
    "q": "fuga",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "aut",
    "sort": "most_viewed",
    "sort_type": "asc",
    "page": 63,
    "limit": 11
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/activitypoint/package

URL Parameters

ver string

Query Parameters

q string optional

search text

Body Parameters

q string optional

sort string optional

Must be one of recent, most_discussed, most_viewed, most_liked, or latest.

sort_type string optional

Must be one of desc or asc.

page integer optional

Must be at least 1.

limit integer optional

Browse item.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/qui/activitypoint/package-transaction" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "facere",
    "status": "autem",
    "from": "2024-08-02T08:10:38",
    "to": "2024-08-02T08:10:38",
    "sort": "most_liked",
    "sort_type": "desc",
    "page": 37,
    "limit": 8
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/qui/activitypoint/package-transaction',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'facere',
            'status' => 'autem',
            'from' => '2024-08-02T08:10:38',
            'to' => '2024-08-02T08:10:38',
            'sort' => 'most_liked',
            'sort_type' => 'desc',
            'page' => 37,
            'limit' => 8,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/activitypoint/package-transaction"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "facere",
    "status": "autem",
    "from": "2024-08-02T08:10:38",
    "to": "2024-08-02T08:10:38",
    "sort": "most_liked",
    "sort_type": "desc",
    "page": 37,
    "limit": 8
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/activitypoint/package-transaction

URL Parameters

ver string

Body Parameters

q string optional

status string optional

from string optional

Must be a valid date.

to string optional

Must be a valid date.

sort string optional

Must be one of recent, most_discussed, most_viewed, most_liked, or latest.

sort_type string optional

Must be one of desc or asc.

page integer optional

Must be at least 1.

limit integer optional

POST api/{ver}/activitypoint/package/purchase/{id}

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/minima/activitypoint/package/purchase/12" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "payment_gateway": 6
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/minima/activitypoint/package/purchase/12',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'payment_gateway' => 6,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/minima/activitypoint/package/purchase/12"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "payment_gateway": 6
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View item.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sed/activitypoint/package/605" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sed/activitypoint/package/605',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sed/activitypoint/package/605"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/rerum/activitypoint/setting" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sort": "most_viewed",
    "sort_type": "asc"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/rerum/activitypoint/setting',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sort' => 'most_viewed',
            'sort_type' => 'asc',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/rerum/activitypoint/setting"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sort": "most_viewed",
    "sort_type": "asc"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View item.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/architecto/activitypoint/statistic/88" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/architecto/activitypoint/statistic/88',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/architecto/activitypoint/statistic/88"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/asperiores/activitypoint/transaction" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "type": 1,
    "from": "2024-08-02T08:10:38",
    "to": "2040-03-14",
    "sort": "most_discussed",
    "sort_type": "asc",
    "page": 37,
    "limit": 10
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/asperiores/activitypoint/transaction',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'type' => 1,
            'from' => '2024-08-02T08:10:38',
            'to' => '2040-03-14',
            'sort' => 'most_discussed',
            'sort_type' => 'asc',
            'page' => 37,
            'limit' => 10,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/asperiores/activitypoint/transaction"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "type": 1,
    "from": "2024-08-02T08:10:38",
    "to": "2040-03-14",
    "sort": "most_discussed",
    "sort_type": "asc",
    "page": 37,
    "limit": 10
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/activitypoint/transaction

URL Parameters

ver string

Body Parameters

type integer optional

from string optional

Must be a valid date.

to string optional

Must be a valid date. Must be a date after from.

sort string optional

Must be one of recent, most_discussed, most_viewed, most_liked, or latest.

sort_type string optional

Must be one of desc or asc.

page integer optional

Must be at least 1.

limit integer optional

View item.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/beatae/activitypoint/transaction/0" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/beatae/activitypoint/transaction/0',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/beatae/activitypoint/transaction/0"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Advertise

App name: Advertise Version: 5.0.14 Author: phpFox Updated at: Aug 02, 2024

GET api/{ver}/advertise/advertise

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/qui/advertise/advertise" \
    --header "Content-Type: application/json" \
    --data "{
    "placement_id": 489.7407,
    "start_date": "nulla",
    "end_date": "accusantium",
    "status": "quaerat",
    "page": 71,
    "limit": 11.27982
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/qui/advertise/advertise',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'placement_id' => 489.7407,
            'start_date' => 'nulla',
            'end_date' => 'accusantium',
            'status' => 'quaerat',
            'page' => 71,
            'limit' => 11.27982,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/advertise/advertise"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "placement_id": 489.7407,
    "start_date": "nulla",
    "end_date": "accusantium",
    "status": "quaerat",
    "page": 71,
    "limit": 11.27982
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/advertise/advertise

URL Parameters

ver string

Body Parameters

placement_id number optional

view string optional

start_date string optional

end_date string optional

status string optional

page number optional

Must be at least 1.

limit number optional

POST api/{ver}/advertise/advertise

Example request:

curl --request POST \
    "http://localhost/api/v1/api/aut/advertise/advertise" \
    --header "Content-Type: application/json" \
    --data "{
    "placement_id": 1287837.94956,
    "image": {
        "status": "in",
        "temp_file": 311.24629
    },
    "url": "https:\/\/www.schowalter.com\/et-consequuntur-reiciendis-natus-nisi-et",
    "image_tooltip": "lxptiesrqtpgrxxzu",
    "html_title": "bzhfkea",
    "html_description": "sgwblbuhxznw",
    "title": "dpktceabwqkce",
    "age_from": 25,
    "languages": [
        "aut"
    ],
    "start_date": "2024-08-02T08:10:38",
    "creation_type": "dolores"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/aut/advertise/advertise',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'placement_id' => 1287837.94956,
            'image' => [
                'status' => 'in',
                'temp_file' => 311.24629,
            ],
            'url' => 'https://www.schowalter.com/et-consequuntur-reiciendis-natus-nisi-et',
            'image_tooltip' => 'lxptiesrqtpgrxxzu',
            'html_title' => 'bzhfkea',
            'html_description' => 'sgwblbuhxznw',
            'title' => 'dpktceabwqkce',
            'age_from' => 25,
            'languages' => [
                'aut',
            ],
            'start_date' => '2024-08-02T08:10:38',
            'creation_type' => 'dolores',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/advertise/advertise"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "placement_id": 1287837.94956,
    "image": {
        "status": "in",
        "temp_file": 311.24629
    },
    "url": "https:\/\/www.schowalter.com\/et-consequuntur-reiciendis-natus-nisi-et",
    "image_tooltip": "lxptiesrqtpgrxxzu",
    "html_title": "bzhfkea",
    "html_description": "sgwblbuhxznw",
    "title": "dpktceabwqkce",
    "age_from": 25,
    "languages": [
        "aut"
    ],
    "start_date": "2024-08-02T08:10:38",
    "creation_type": "dolores"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/advertise/advertise

URL Parameters

ver string

Body Parameters

placement_id number

image object

image.status string optional

This field is required when image.temp_file is present.

image.temp_file number optional

This field is required when image.id is 0.

url string

Must be a valid URL.

image_tooltip string optional

Must not be greater than 255 characters.

html_title string optional

This field is required when creation_type is html. Must not be greater than 25 characters.

html_description string optional

Must not be greater than 135 characters.

title string

Must not be greater than 255 characters.

total_click string optional

total_impression string optional

genders string[] optional

This field is required when genders is present.

age_from integer optional

Must be at least 1.

age_to string optional

languages string[] optional

This field is required when languages is present.

is_active string optional

start_date string

Must be a valid date.

end_date string optional

creation_type string

location object optional

Must have at least {min, plural, =1 {# item} other {# items}}.

PATCH api/{ver}/advertise/advertise/active/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/id/advertise/advertise/active/614"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/id/advertise/advertise/active/614');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/id/advertise/advertise/active/614"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/advertise/advertise/hide/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/qui/advertise/advertise/hide/01150"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/qui/advertise/advertise/hide/01150');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/advertise/advertise/hide/01150"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/advertise/advertise/report/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/unde/advertise/advertise/report/34553" \
    --header "Content-Type: application/json" \
    --data "{
    "report_type": "sint",
    "view": "sequi",
    "start_date_month": "quod",
    "end_date_month": "qui",
    "start_date_week": "iste",
    "end_date_week": "molestiae",
    "start_date_day": "accusamus",
    "end_date_day": "rerum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/unde/advertise/advertise/report/34553',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'report_type' => 'sint',
            'view' => 'sequi',
            'start_date_month' => 'quod',
            'end_date_month' => 'qui',
            'start_date_week' => 'iste',
            'end_date_week' => 'molestiae',
            'start_date_day' => 'accusamus',
            'end_date_day' => 'rerum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/unde/advertise/advertise/report/34553"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "report_type": "sint",
    "view": "sequi",
    "start_date_month": "quod",
    "end_date_month": "qui",
    "start_date_week": "iste",
    "end_date_week": "molestiae",
    "start_date_day": "accusamus",
    "end_date_day": "rerum"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/advertise/advertise/report/{id}

URL Parameters

ver string

id string

The ID of the report.

Body Parameters

report_type string

view string

start_date_month string optional

end_date_month string optional

start_date_week string optional

end_date_week string optional

start_date_day string optional

end_date_day string optional

GET api/{ver}/advertise/advertise/show

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/et/advertise/advertise/show" \
    --header "Content-Type: application/json" \
    --data "{
    "placement_id": 1106342,
    "location": "nesciunt"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/et/advertise/advertise/show',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'placement_id' => 1106342.0,
            'location' => 'nesciunt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/advertise/advertise/show"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "placement_id": 1106342,
    "location": "nesciunt"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/advertise/advertise/total/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/aperiam/advertise/advertise/total/4" \
    --header "Content-Type: application/json" \
    --data "{
    "type": "eveniet"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/aperiam/advertise/advertise/total/4',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'type' => 'eveniet',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aperiam/advertise/advertise/total/4"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "type": "eveniet"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/et/advertise/advertise/28"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/et/advertise/advertise/28');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/advertise/advertise/28"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/advertise/advertise/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/asperiores/advertise/advertise/9" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "iswogbo",
    "age_from": 55,
    "age_to": 709782.2,
    "languages": [
        "temporibus"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/asperiores/advertise/advertise/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'iswogbo',
            'age_from' => 55,
            'age_to' => 709782.2,
            'languages' => [
                'temporibus',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/asperiores/advertise/advertise/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "iswogbo",
    "age_from": 55,
    "age_to": 709782.2,
    "languages": [
        "temporibus"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/advertise/advertise/{id}

PATCH api/{ver}/advertise/advertise/{id}

URL Parameters

ver string

id string

The ID of the advertise.

Body Parameters

title string

Must not be greater than 255 characters.

genders string[] optional

This field is required when genders is present.

age_from number optional

Must be at least 1.

age_to number optional

languages string[] optional

This field is required when languages is present.

location object optional

Must have at least {min, plural, =1 {# item} other {# items}}.

Delete item.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/ut/advertise/advertise/32"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/ut/advertise/advertise/32');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/advertise/advertise/32"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptas/advertise/invoice" \
    --header "Content-Type: application/json" \
    --data "{
    "start_date": "deleniti",
    "end_date": "qui",
    "status": "sunt",
    "page": 3,
    "limit": 19049969.9
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptas/advertise/invoice',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'start_date' => 'deleniti',
            'end_date' => 'qui',
            'status' => 'sunt',
            'page' => 3,
            'limit' => 19049969.9,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/advertise/invoice"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "start_date": "deleniti",
    "end_date": "qui",
    "status": "sunt",
    "page": 3,
    "limit": 19049969.9
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/advertise/invoice

URL Parameters

ver string

Body Parameters

start_date string optional

end_date string optional

status string optional

page number optional

Must be at least 1.

limit number optional

PATCH api/{ver}/advertise/invoice/cancel/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/ut/advertise/invoice/cancel/5334"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/ut/advertise/invoice/cancel/5334');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/advertise/invoice/cancel/5334"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/advertise/invoice/change

Example request:

curl --request POST \
    "http://localhost/api/v1/api/quam/advertise/invoice/change" \
    --header "Content-Type: application/json" \
    --data "{
    "invoice_id": 9.24132404,
    "item_id": 45,
    "item_type": "delectus",
    "payment_gateway": 39414632
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/quam/advertise/invoice/change',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'invoice_id' => 9.24132404,
            'item_id' => 45,
            'item_type' => 'delectus',
            'payment_gateway' => 39414632.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quam/advertise/invoice/change"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "invoice_id": 9.24132404,
    "item_id": 45,
    "item_type": "delectus",
    "payment_gateway": 39414632
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/advertise/invoice/change

URL Parameters

ver string

Body Parameters

invoice_id number optional

item_id number

Must be at least 1.

item_type string

payment_gateway number optional

POST api/{ver}/advertise/invoice/payment

Example request:

curl --request POST \
    "http://localhost/api/v1/api/voluptatem/advertise/invoice/payment" \
    --header "Content-Type: application/json" \
    --data "{
    "invoice_id": 9335,
    "item_id": 85,
    "item_type": "dolores",
    "payment_gateway": 5585.9355
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/voluptatem/advertise/invoice/payment',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'invoice_id' => 9335.0,
            'item_id' => 85,
            'item_type' => 'dolores',
            'payment_gateway' => 5585.9355,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatem/advertise/invoice/payment"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "invoice_id": 9335,
    "item_id": 85,
    "item_type": "dolores",
    "payment_gateway": 5585.9355
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/advertise/invoice/payment

URL Parameters

ver string

Body Parameters

invoice_id number optional

item_id number

Must be at least 1.

item_type string

payment_gateway number optional

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/corporis/advertise/sponsor" \
    --header "Content-Type: application/json" \
    --data "{
    "start_date": "soluta",
    "end_date": "quia",
    "status": "iste",
    "page": 70,
    "limit": 65604908
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/corporis/advertise/sponsor',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'start_date' => 'soluta',
            'end_date' => 'quia',
            'status' => 'iste',
            'page' => 70,
            'limit' => 65604908.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/corporis/advertise/sponsor"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "start_date": "soluta",
    "end_date": "quia",
    "status": "iste",
    "page": 70,
    "limit": 65604908
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request POST \
    "http://localhost/api/v1/api/non/advertise/sponsor" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "ztmihaceslerh",
    "age_from": 43,
    "languages": [
        "eos"
    ],
    "start_date": "2024-08-02T08:10:38",
    "item_type": "aspernatur",
    "item_id": 1,
    "total_impression": 92
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/non/advertise/sponsor',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'ztmihaceslerh',
            'age_from' => 43,
            'languages' => [
                'eos',
            ],
            'start_date' => '2024-08-02T08:10:38',
            'item_type' => 'aspernatur',
            'item_id' => 1,
            'total_impression' => 92,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/non/advertise/sponsor"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "ztmihaceslerh",
    "age_from": 43,
    "languages": [
        "eos"
    ],
    "start_date": "2024-08-02T08:10:38",
    "item_type": "aspernatur",
    "item_id": 1,
    "total_impression": 92
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/natus/advertise/sponsor/active/0222"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/natus/advertise/sponsor/active/0222');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/natus/advertise/sponsor/active/0222"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request POST \
    "http://localhost/api/v1/api/et/advertise/sponsor/feed" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "iivkvutnvggzodttutln",
    "age_from": 14,
    "languages": [
        "iure"
    ],
    "start_date": "2024-08-02T08:10:38",
    "item_type": "aperiam",
    "item_id": 18,
    "total_impression": 91
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/et/advertise/sponsor/feed',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'iivkvutnvggzodttutln',
            'age_from' => 14,
            'languages' => [
                'iure',
            ],
            'start_date' => '2024-08-02T08:10:38',
            'item_type' => 'aperiam',
            'item_id' => 18,
            'total_impression' => 91,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/advertise/sponsor/feed"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "iivkvutnvggzodttutln",
    "age_from": 14,
    "languages": [
        "iure"
    ],
    "start_date": "2024-08-02T08:10:38",
    "item_type": "aperiam",
    "item_id": 18,
    "total_impression": 91
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/maxime/advertise/sponsor/form/feed/ipsum/inventore"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/maxime/advertise/sponsor/form/feed/ipsum/inventore');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/maxime/advertise/sponsor/form/feed/ipsum/inventore"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/molestiae/advertise/sponsor/form/laudantium/est"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/molestiae/advertise/sponsor/form/laudantium/est');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/molestiae/advertise/sponsor/form/laudantium/est"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/et/advertise/sponsor/554"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/et/advertise/sponsor/554');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/advertise/sponsor/554"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/sint/advertise/sponsor/61" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "renzquucrflhyoashzzk",
    "age_from": 27,
    "languages": [
        "voluptatem"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/sint/advertise/sponsor/61',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'renzquucrflhyoashzzk',
            'age_from' => 27,
            'languages' => [
                'voluptatem',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sint/advertise/sponsor/61"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "renzquucrflhyoashzzk",
    "age_from": 27,
    "languages": [
        "voluptatem"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/voluptates/advertise/sponsor/17"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/voluptates/advertise/sponsor/17');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptates/advertise/sponsor/17"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request POST \
    "http://localhost/api/v1/api/ipsa/sponsor/total/click" \
    --header "Content-Type: application/json" \
    --data "{
    "item_type": "animi",
    "item_ids": []
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/ipsa/sponsor/total/click',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_type' => 'animi',
            'item_ids' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ipsa/sponsor/total/click"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_type": "animi",
    "item_ids": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request POST \
    "http://localhost/api/v1/api/eligendi/sponsor/total/view" \
    --header "Content-Type: application/json" \
    --data "{
    "item_type": "omnis",
    "item_ids": []
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/eligendi/sponsor/total/view',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_type' => 'omnis',
            'item_ids' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eligendi/sponsor/total/view"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_type": "omnis",
    "item_ids": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Announcement

App name: Announcement Version: 5.0.16 Author: phpFox Updated at: Aug 02, 2024

Browse announcement.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/itaque/announcement?limit=10" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/itaque/announcement',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
        'query' => [
            'limit'=> '10',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/itaque/announcement"
);

const params = {
    "limit": "10",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Browse announcement.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/expedita/announcement/view?announcement_id=308514161.09299&limit=10" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/expedita/announcement/view',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
        'query' => [
            'announcement_id'=> '308514161.09299',
            'limit'=> '10',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/expedita/announcement/view"
);

const params = {
    "announcement_id": "308514161.09299",
    "limit": "10",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Hide announcement.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/vitae/announcement/view" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "announcement_id": 64
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/vitae/announcement/view',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'announcement_id' => 64,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/vitae/announcement/view"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "announcement_id": 64
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View announcement.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/pariatur/announcement/77100" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/pariatur/announcement/77100',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/pariatur/announcement/77100"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Attachments

App name: Attachments Version: 5.0.4 Author: phpFox Updated at: Aug 02, 2024

Upload attachment.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/maxime/attachment" \
    --header "Content-Type: multipart/form-data" \
    --form "storage_id=beatae" \
    --form "item_type=et" \
    --form "upload_type=deleniti" \
    --form "file=@/tmp/phpn1PDDx"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/maxime/attachment',
    [
        'headers' => [
            'Content-Type' => 'multipart/form-data',
        ],
        'multipart' => [
            [
                'name' => 'storage_id',
                'contents' => 'beatae'
            ],
            [
                'name' => 'item_type',
                'contents' => 'et'
            ],
            [
                'name' => 'upload_type',
                'contents' => 'deleniti'
            ],
            [
                'name' => 'file',
                'contents' => fopen('/tmp/phpn1PDDx', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/maxime/attachment"
);

const headers = {
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
};

const body = new FormData();
body.append('storage_id', 'beatae');
body.append('item_type', 'et');
body.append('upload_type', 'deleniti');
body.append('file', document.querySelector('input[name="file"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/attachment

URL Parameters

ver string

Body Parameters

storage_id string optional

file file

Must be a file. Must not be greater than 8192 kilobytes.

item_type string

upload_type string optional

Allow downloading resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/labore/attachment/download/3"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/labore/attachment/download/3');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/labore/attachment/download/3"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Authorization

App name: Authorization Version: 5.0.14 Author: phpFox Updated at: Aug 02, 2024

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/autem/authorization/device" \
    --header "Content-Type: application/json" \
    --data "{
    "device_token": "molestias",
    "device_id": "ea",
    "device_uid": "qui",
    "token_source": "dolores",
    "platform": "officia",
    "platform_version": "alias"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/autem/authorization/device',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'device_token' => 'molestias',
            'device_id' => 'ea',
            'device_uid' => 'qui',
            'token_source' => 'dolores',
            'platform' => 'officia',
            'platform_version' => 'alias',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/autem/authorization/device"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "device_token": "molestias",
    "device_id": "ea",
    "device_uid": "qui",
    "token_source": "dolores",
    "platform": "officia",
    "platform_version": "alias"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/authorization/device

URL Parameters

ver string

Body Parameters

device_token string

device_id string

device_uid string optional

token_source string

platform string optional

platform_version string optional

extra object optional

PATCH api/{ver}/authorization/device/logout-all

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/aut/authorization/device/logout-all"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/aut/authorization/device/logout-all');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/authorization/device/logout-all"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

Blog

App name: Blog Version: 5.0.17 Author: phpFox Updated at: Aug 02, 2024

Browse blog.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/doloremque/blog?q=omnis&view=all&sort=latest&sort_type=asc&when=this_month&category_id=17&user_id=0&owner_id=15&page=47&limit=16" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/doloremque/blog',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
        'query' => [
            'q'=> 'omnis',
            'view'=> 'all',
            'sort'=> 'latest',
            'sort_type'=> 'asc',
            'when'=> 'this_month',
            'category_id'=> '17',
            'user_id'=> '0',
            'owner_id'=> '15',
            'page'=> '47',
            'limit'=> '16',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/doloremque/blog"
);

const params = {
    "q": "omnis",
    "view": "all",
    "sort": "latest",
    "sort_type": "asc",
    "when": "this_month",
    "category_id": "17",
    "user_id": "0",
    "owner_id": "15",
    "page": "47",
    "limit": "16",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/blog

URL Parameters

ver string

Query Parameters

q string optional

view string optional

Must be one of all, my, pending, feature, sponsor, search, my_pending, draft, or friend.

sort string optional

Must be one of recent, most_discussed, most_viewed, most_liked, or latest.

sort_type string optional

Must be one of desc or asc.

when string optional

Must be one of all, this_month, this_week, or today.

category_id integer optional

user_id integer optional

The profile id to filter.

owner_id integer optional

page integer optional

Must be at least 1.

limit integer optional

is_featured string optional

Create blog.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/dolore/blog" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "et",
    "categories": [
        43.6
    ],
    "owner_id": 153.716,
    "file": {
        "temp_file": 67735.097656496
    },
    "text": "eos",
    "draft": 6132.264,
    "tags": [
        "ad"
    ],
    "privacy": "dolore",
    "attachments": [
        "veritatis"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/dolore/blog',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'et',
            'categories' => [
                43.6,
            ],
            'owner_id' => 153.716,
            'file' => [
                'temp_file' => 67735.097656496,
            ],
            'text' => 'eos',
            'draft' => 6132.264,
            'tags' => [
                'ad',
            ],
            'privacy' => 'dolore',
            'attachments' => [
                'veritatis',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolore/blog"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "et",
    "categories": [
        43.6
    ],
    "owner_id": 153.716,
    "file": {
        "temp_file": 67735.097656496
    },
    "text": "eos",
    "draft": 6132.264,
    "tags": [
        "ad"
    ],
    "privacy": "dolore",
    "attachments": [
        "veritatis"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/blog

URL Parameters

ver string

Body Parameters

title string

categories number[] optional

owner_id number optional

file object optional

file.temp_file number optional

This field is required when file is present.

text string

draft number optional

tags string[] optional

privacy string

captcha string optional

attachments number[] optional

attachments[].id number optional

attachments[].status string optional

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ad/blog-category" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 0,
    "page": 11,
    "q": "quia",
    "level": 44382,
    "limit": 4450.50019
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ad/blog-category',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 0.0,
            'page' => 11,
            'q' => 'quia',
            'level' => 44382.0,
            'limit' => 4450.50019,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ad/blog-category"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 0,
    "page": 11,
    "q": "quia",
    "level": 44382,
    "limit": 4450.50019
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/blog-category

URL Parameters

ver string

Body Parameters

id number optional

page number optional

Must be at least 1.

q string optional

level number optional

limit number optional

Approve blog.

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/eligendi/blog/approve/2336" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/eligendi/blog/approve/2336',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eligendi/blog/approve/2336"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Feature blog.

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/totam/blog/feature/91521" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "1"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/totam/blog/feature/91521',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/totam/blog/feature/91521"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "1"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/blog/form

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/rerum/blog/form" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "owner_id": 14.44484
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/rerum/blog/form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'owner_id' => 14.44484,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/rerum/blog/form"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "owner_id": 14.44484
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/blog/form/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/alias/blog/form/8124" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "owner_id": 27
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/alias/blog/form/8124',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'owner_id' => 27.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/alias/blog/form/8124"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "owner_id": 27
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Publish blog.

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/totam/blog/publish/14" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/totam/blog/publish/14',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/totam/blog/publish/14"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/et/blog/search-form" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/et/blog/search-form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/blog/search-form"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/exercitationem/blog/sponsor-in-feed/4" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": 219
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/exercitationem/blog/sponsor-in-feed/4',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 219.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/exercitationem/blog/sponsor-in-feed/4"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": 219
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/consequatur/blog/sponsor/84586" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "eligendi"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/consequatur/blog/sponsor/84586',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'eligendi',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consequatur/blog/sponsor/84586"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "eligendi"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View Blog.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sequi/blog/2" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sequi/blog/2',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sequi/blog/2"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Update blog.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/sed/blog/13" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "rerum",
    "categories": [
        80
    ],
    "file": {
        "temp_file": 66.78084,
        "status": "et"
    },
    "text": "possimus",
    "tags": [
        "magni"
    ],
    "draft": 28883.7489,
    "published": true,
    "attachments": [
        "nisi"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/sed/blog/13',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'rerum',
            'categories' => [
                80,
            ],
            'file' => [
                'temp_file' => 66.78084,
                'status' => 'et',
            ],
            'text' => 'possimus',
            'tags' => [
                'magni',
            ],
            'draft' => 28883.7489,
            'published' => true,
            'attachments' => [
                'nisi',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sed/blog/13"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "rerum",
    "categories": [
        80
    ],
    "file": {
        "temp_file": 66.78084,
        "status": "et"
    },
    "text": "possimus",
    "tags": [
        "magni"
    ],
    "draft": 28883.7489,
    "published": true,
    "attachments": [
        "nisi"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/blog/{id}

PATCH api/{ver}/blog/{id}

URL Parameters

ver string

id string

The ID of the blog.

Body Parameters

title string optional

categories integer[] optional

Must be at least 1.

file object optional

file.temp_file number optional

This field is required when file.status is update.

file.status string optional

This field is required when file is present.

text string optional

tags string[] optional

draft number optional

published boolean optional

privacy string optional

attachments number[] optional

attachments[].id number optional

attachments[].status string optional

captcha string optional

Delete blog.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/dolor/blog/8" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/dolor/blog/8',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolor/blog/8"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

CAPTCHA

App name: CAPTCHA Version: 5.0.11 Author: phpFox Updated at: Aug 02, 2024

POST api/{ver}/captcha/verify

Example request:

curl --request POST \
    "http://localhost/api/v1/api/illum/captcha/verify" \
    --header "Content-Type: application/json" \
    --data "{
    "action_name": "velit"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/illum/captcha/verify',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'action_name' => 'velit',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/illum/captcha/verify"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "action_name": "velit"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/image-captcha/refresh

Example request:

curl --request POST \
    "http://localhost/api/v1/api/reiciendis/image-captcha/refresh"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/reiciendis/image-captcha/refresh');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/reiciendis/image-captcha/refresh"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

Chat

App name: Chat Version: 5.0.18 Author: phpFox Updated at: Aug 02, 2024

GET api/{ver}/chat

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/beatae/chat" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "qui",
    "message_id": 1774.7,
    "room_id": 0.6,
    "last_message_id": 808.6239,
    "scroll": "perspiciatis",
    "upper_bound": 17,
    "lower_bound": 66,
    "page": 30,
    "limit": 14
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/beatae/chat',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'qui',
            'message_id' => 1774.7,
            'room_id' => 0.6,
            'last_message_id' => 808.6239,
            'scroll' => 'perspiciatis',
            'upper_bound' => 17,
            'lower_bound' => 66,
            'page' => 30,
            'limit' => 14,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/beatae/chat"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "qui",
    "message_id": 1774.7,
    "room_id": 0.6,
    "last_message_id": 808.6239,
    "scroll": "perspiciatis",
    "upper_bound": 17,
    "lower_bound": 66,
    "page": 30,
    "limit": 14
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/chat

URL Parameters

ver string

Body Parameters

q string optional

message_id number optional

room_id number

last_message_id number optional

scroll string optional

upper_bound number optional

Must be at least 1.

lower_bound number optional

Must be at least 1.

page integer optional

Must be at least 1.

limit integer optional

POST api/{ver}/chat

Example request:

curl --request POST \
    "http://localhost/api/v1/api/esse/chat" \
    --header "Content-Type: application/json" \
    --data "{
    "room_id": 73924092.65,
    "message": "natus",
    "type": "voluptatem",
    "reply_id": 3,
    "tempId": "suscipit",
    "attachments": [
        "magnam"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/esse/chat',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'room_id' => 73924092.65,
            'message' => 'natus',
            'type' => 'voluptatem',
            'reply_id' => 3,
            'tempId' => 'suscipit',
            'attachments' => [
                'magnam',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/esse/chat"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "room_id": 73924092.65,
    "message": "natus",
    "type": "voluptatem",
    "reply_id": 3,
    "tempId": "suscipit",
    "attachments": [
        "magnam"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/chat

URL Parameters

ver string

Body Parameters

room_id number optional

message string optional

type string optional

reply_id integer optional

tempId string optional

attachments number[] optional

attachments[].id number optional

attachments[].status string optional

GET api/{ver}/chat-room

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sit/chat-room" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "dolores",
    "page": 22,
    "limit": 16
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sit/chat-room',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'dolores',
            'page' => 22,
            'limit' => 16,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sit/chat-room"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "dolores",
    "page": 22,
    "limit": 16
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/chat-room

Example request:

curl --request POST \
    "http://localhost/api/v1/api/illum/chat-room" \
    --header "Content-Type: application/json" \
    --data "{
    "member_ids": [
        543269.332345123
    ],
    "users": [
        "modi"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/illum/chat-room',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'member_ids' => [
                543269.332345123,
            ],
            'users' => [
                'modi',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/illum/chat-room"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "member_ids": [
        543269.332345123
    ],
    "users": [
        "modi"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/chat-room

URL Parameters

ver string

Body Parameters

member_ids number[] optional

users number[] optional

users[].id number optional

GET api/{ver}/chat-room/addForm

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/magni/chat-room/addForm"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/magni/chat-room/addForm');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/magni/chat-room/addForm"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/chat-room/mark-all-read

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/qui/chat-room/mark-all-read" \
    --header "Content-Type: application/json" \
    --data "{
    "room_ids": [
        372330.412638
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/qui/chat-room/mark-all-read',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'room_ids' => [
                372330.412638,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/chat-room/mark-all-read"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "room_ids": [
        372330.412638
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/chat-room/mark-read/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/omnis/chat-room/mark-read/8501"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/omnis/chat-room/mark-read/8501');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/omnis/chat-room/mark-read/8501"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/chat-room/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/et/chat-room/291"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/et/chat-room/291');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/chat-room/291"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/chat-room/{id}

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/expedita/chat-room/3321"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/expedita/chat-room/3321');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/expedita/chat-room/3321"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

Display the specified resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dolores/chat/download/472558"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/dolores/chat/download/472558');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolores/chat/download/472558"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/chat/react/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/culpa/chat/react/1" \
    --header "Content-Type: application/json" \
    --data "{
    "react": "autem",
    "remove": false
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/culpa/chat/react/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'react' => 'autem',
            'remove' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/culpa/chat/react/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "react": "autem",
    "remove": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/chat/react/{id}

URL Parameters

ver string

id string

The ID of the react.

Body Parameters

react string optional

remove boolean optional

PUT api/{ver}/chat/remove/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/voluptatem/chat/remove/36216"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/voluptatem/chat/remove/36216');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatem/chat/remove/36216"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/chat/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/enim/chat/2"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/enim/chat/2');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/enim/chat/2"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/chat/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/dolores/chat/30" \
    --header "Content-Type: application/json" \
    --data "{
    "message": "laudantium",
    "type": "dolorum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/dolores/chat/30',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'message' => 'laudantium',
            'type' => 'dolorum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolores/chat/30"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "message": "laudantium",
    "type": "dolorum"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

ChatPlus

App name: ChatPlus Version: 5.0.24 Author: phpFox Updated at: Aug 02, 2024

GET api/{ver}/chatplus/can-create-direct-message/{type}/{id_from}/{id_to}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/incidunt/chatplus/can-create-direct-message/aspernatur/facilis/in" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/incidunt/chatplus/can-create-direct-message/aspernatur/facilis/in',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/incidunt/chatplus/can-create-direct-message/aspernatur/facilis/in"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/chatplus/export-users

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/nemo/chatplus/export-users" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/nemo/chatplus/export-users',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nemo/chatplus/export-users"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/chatplus/jobs

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/maiores/chatplus/jobs" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/maiores/chatplus/jobs',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/maiores/chatplus/jobs"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/chatplus/me

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/recusandae/chatplus/me" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/recusandae/chatplus/me',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/recusandae/chatplus/me"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/chatplus/prefetch-users

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dolores/chatplus/prefetch-users" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/dolores/chatplus/prefetch-users',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolores/chatplus/prefetch-users"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/chatplus/rooms/upload/{room_id}

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/numquam/chatplus/rooms/upload/cupiditate" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "userId": "eum",
    "roomId": "neque",
    "token": "laudantium",
    "msg": "voluptatum",
    "file": []
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/numquam/chatplus/rooms/upload/cupiditate',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'userId' => 'eum',
            'roomId' => 'neque',
            'token' => 'laudantium',
            'msg' => 'voluptatum',
            'file' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/numquam/chatplus/rooms/upload/cupiditate"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "userId": "eum",
    "roomId": "neque",
    "token": "laudantium",
    "msg": "voluptatum",
    "file": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/chatplus/rooms/upload/{room_id}

URL Parameters

ver string

room_id string

The ID of the room.

Body Parameters

userId string

roomId string

token string

msg string optional

file object

GET api/{ver}/chatplus/settings

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/omnis/chatplus/settings" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/omnis/chatplus/settings',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/omnis/chatplus/settings"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/chatplus/spotlight

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sint/chatplus/spotlight" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sint/chatplus/spotlight',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sint/chatplus/spotlight"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/chatplus/user/{type}/{query}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aliquid/chatplus/user/dolorem/enim" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aliquid/chatplus/user/dolorem/enim',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aliquid/chatplus/user/dolorem/enim"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Comment

App name: Comment Version: 5.0.18 Author: phpFox Updated at: Aug 02, 2024

Browse comments.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/amet/comment" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 101429069.948,
    "item_type": "aut",
    "parent_id": 5.65656,
    "page": 40,
    "limit": 88,
    "sort": "autem",
    "sort_type": "sit",
    "last_id": 0.085758,
    "excludes": [
        3.5701
    ],
    "comment_id": 16
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/amet/comment',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 101429069.948,
            'item_type' => 'aut',
            'parent_id' => 5.65656,
            'page' => 40,
            'limit' => 88.0,
            'sort' => 'autem',
            'sort_type' => 'sit',
            'last_id' => 0.085758,
            'excludes' => [
                3.5701,
            ],
            'comment_id' => 16,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/amet/comment"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 101429069.948,
    "item_type": "aut",
    "parent_id": 5.65656,
    "page": 40,
    "limit": 88,
    "sort": "autem",
    "sort_type": "sit",
    "last_id": 0.085758,
    "excludes": [
        3.5701
    ],
    "comment_id": 16
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/comment

URL Parameters

ver string

Body Parameters

item_id number

item_type string

parent_id number optional

page number optional

Must be at least 1.

limit number optional

sort string optional

sort_type string optional

last_id number optional

excludes number[] optional

comment_id integer optional

Create comment.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/consectetur/comment" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 78004,
    "item_type": "aperiam",
    "text": "vero",
    "parent_id": 52569535.72,
    "photo_id": 459.591,
    "sticker_id": 133297958.92801
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/consectetur/comment',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 78004.0,
            'item_type' => 'aperiam',
            'text' => 'vero',
            'parent_id' => 52569535.72,
            'photo_id' => 459.591,
            'sticker_id' => 133297958.92801,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consectetur/comment"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 78004,
    "item_type": "aperiam",
    "text": "vero",
    "parent_id": 52569535.72,
    "photo_id": 459.591,
    "sticker_id": 133297958.92801
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/comment

URL Parameters

ver string

Body Parameters

item_id number

item_type string

text string optional

This field is required when none of photo_id and sticker_id are present.

parent_id number optional

photo_id number optional

sticker_id number optional

captcha string optional

GET api/{ver}/comment-lists

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/qui/comment-lists" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 7027.62989,
    "item_type": "expedita",
    "parent_id": 179886608.8894273,
    "page": 76,
    "limit": 861.393965,
    "sort": "aut",
    "sort_type": "et",
    "last_id": 19.62853041,
    "excludes": [
        89659.7
    ],
    "comment_id": 12
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/qui/comment-lists',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 7027.62989,
            'item_type' => 'expedita',
            'parent_id' => 179886608.8894273,
            'page' => 76,
            'limit' => 861.393965,
            'sort' => 'aut',
            'sort_type' => 'et',
            'last_id' => 19.62853041,
            'excludes' => [
                89659.7,
            ],
            'comment_id' => 12,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/comment-lists"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 7027.62989,
    "item_type": "expedita",
    "parent_id": 179886608.8894273,
    "page": 76,
    "limit": 861.393965,
    "sort": "aut",
    "sort_type": "et",
    "last_id": 19.62853041,
    "excludes": [
        89659.7
    ],
    "comment_id": 12
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/comment-lists

URL Parameters

ver string

Body Parameters

item_id number

item_type string

parent_id number optional

page number optional

Must be at least 1.

limit number optional

sort string optional

sort_type string optional

last_id number optional

excludes number[] optional

comment_id integer optional

Approve comment.

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/ad/comment/approve/0" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/ad/comment/approve/0',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ad/comment/approve/0"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/comment/download/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ea/comment/download/9616" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ea/comment/download/9616',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ea/comment/download/9616"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/voluptates/comment/hide" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "comment_id": 86728.058328,
    "is_hidden": "illum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/voluptates/comment/hide',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'comment_id' => 86728.058328,
            'is_hidden' => 'illum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptates/comment/hide"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "comment_id": 86728.058328,
    "is_hidden": "illum"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/comment/history-edit/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sed/comment/history-edit/005" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sed/comment/history-edit/005',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sed/comment/history-edit/005"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/comment/preview/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/maiores/comment/preview/04597" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/maiores/comment/preview/04597',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/maiores/comment/preview/04597"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/at/comment/related-comment" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 1036337.1141512138,
    "item_type": "animi",
    "parent_id": 28464558.22,
    "page": 16,
    "limit": 22405.6465881,
    "sort": "vel",
    "sort_type": "error",
    "last_id": 222489,
    "excludes": [
        2.557
    ],
    "comment_id": 4
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/at/comment/related-comment',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 1036337.1141512138,
            'item_type' => 'animi',
            'parent_id' => 28464558.22,
            'page' => 16,
            'limit' => 22405.6465881,
            'sort' => 'vel',
            'sort_type' => 'error',
            'last_id' => 222489.0,
            'excludes' => [
                2.557,
            ],
            'comment_id' => 4,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/at/comment/related-comment"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 1036337.1141512138,
    "item_type": "animi",
    "parent_id": 28464558.22,
    "page": 16,
    "limit": 22405.6465881,
    "sort": "vel",
    "sort_type": "error",
    "last_id": 222489,
    "excludes": [
        2.557
    ],
    "comment_id": 4
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/comment/reply/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/cumque/comment/reply/03" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/cumque/comment/reply/03',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/cumque/comment/reply/03"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/comment/translate

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ex/comment/translate" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 9,
    "target": "dolores"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ex/comment/translate',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 9,
            'target' => 'dolores',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ex/comment/translate"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 9,
    "target": "dolores"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View comment.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quo/comment/2" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quo/comment/2',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quo/comment/2"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Update comment.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/ab/comment/4620" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "text": "ut",
    "is_hide": 301658454.7211105
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/ab/comment/4620',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'text' => 'ut',
            'is_hide' => 301658454.7211105,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ab/comment/4620"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "text": "ut",
    "is_hide": 301658454.7211105
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/comment/{id}

PATCH api/{ver}/comment/{id}

URL Parameters

ver string

id string

The ID of the comment.

Body Parameters

text string optional

photo_id string optional

is_hide number optional

sticker_id string optional

Remove comment.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/vero/comment/6" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/vero/comment/6',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/vero/comment/6"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/comment/{id}/remove-preview

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/est/comment/40/remove-preview" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/est/comment/40/remove-preview',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/est/comment/40/remove-preview"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Contact

App name: Contact Version: 5.0.14 Author: phpFox Updated at: Aug 02, 2024

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/nostrum/contact" \
    --header "Content-Type: application/json" \
    --data "{
    "category_id": 6,
    "full_name": "rf",
    "subject": "j",
    "email": "[email protected]",
    "message": "culpa",
    "send_copy": 2
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/nostrum/contact',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'category_id' => 6,
            'full_name' => 'rf',
            'subject' => 'j',
            'email' => '[email protected]',
            'message' => 'culpa',
            'send_copy' => 2,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nostrum/contact"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "category_id": 6,
    "full_name": "rf",
    "subject": "j",
    "email": "[email protected]",
    "message": "culpa",
    "send_copy": 2
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/contact

URL Parameters

ver string

Body Parameters

category_id integer

full_name string

Must be between 1 and 255 characters.

subject string

Must be between 1 and 255 characters.

email string

Must be a valid email address. Must be between 1 and 255 characters.

message string

send_copy integer optional

captcha string optional

Core

App name: Core Version: 5.1.13 Author: phpFox Updated at: Aug 02, 2024

View frontend settings.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/eligendi/core/admin/settings/ab"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/eligendi/core/admin/settings/ab');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eligendi/core/admin/settings/ab"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/core/custom-privacy-option

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/et/core/custom-privacy-option" \
    --header "Content-Type: application/json" \
    --data "{
    "item_type": "omnis",
    "item_id": 538125.197968,
    "page": 68,
    "limit": 3629456.7,
    "sort": "facilis",
    "sort_type": "autem"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/et/core/custom-privacy-option',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_type' => 'omnis',
            'item_id' => 538125.197968,
            'page' => 68,
            'limit' => 3629456.7,
            'sort' => 'facilis',
            'sort_type' => 'autem',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/core/custom-privacy-option"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_type": "omnis",
    "item_id": 538125.197968,
    "page": 68,
    "limit": 3629456.7,
    "sort": "facilis",
    "sort_type": "autem"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/core/custom-privacy-option

URL Parameters

ver string

Body Parameters

item_type string optional

item_id number optional

page number optional

Must be at least 1.

limit number optional

sort string optional

sort_type string optional

GET api/{ver}/core/custom-privacy-option/form

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sit/core/custom-privacy-option/form"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/sit/core/custom-privacy-option/form');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sit/core/custom-privacy-option/form"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/core/form/{formName}/{id?}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/error/core/form/sunt/680685"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/error/core/form/sunt/680685');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/error/core/form/sunt/680685"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Show data grid.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/eum/core/grid/quidem/qui?dataGrid=phrase_admin"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/eum/core/grid/quidem/qui',
    [
        'query' => [
            'dataGrid'=> 'phrase_admin',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eum/core/grid/quidem/qui"
);

const params = {
    "dataGrid": "phrase_admin",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

View app settings.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/deserunt/core/mobile/action-settings"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/deserunt/core/mobile/action-settings');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/deserunt/core/mobile/action-settings"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

View app settings.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quo/core/mobile/app-settings"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/quo/core/mobile/app-settings');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quo/core/mobile/app-settings"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/core/mobile/form/{formName}/{id?}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/pariatur/core/mobile/form/ut/04"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/pariatur/core/mobile/form/ut/04');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/pariatur/core/mobile/form/ut/04"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

View app settings.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/similique/core/mobile/settings/similique"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/similique/core/mobile/settings/similique');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/similique/core/mobile/settings/similique"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/core/package/build/callback

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ipsa/core/package/build/callback" \
    --header "Content-Type: application/json" \
    --data "{
    "buildId": "et"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ipsa/core/package/build/callback',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'buildId' => 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ipsa/core/package/build/callback"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "buildId": "et"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View user badge status.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quis/core/status"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/quis/core/status');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quis/core/status"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/core/translation/{group}/{lang?}/{revision?}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quia/core/translation/tempore/perspiciatis/qui"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/quia/core/translation/tempore/perspiciatis/qui');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quia/core/translation/tempore/perspiciatis/qui"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Get canonical URL.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/odit/core/url-to-route" \
    --header "Content-Type: application/json" \
    --data "{
    "url": "sapiente"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/odit/core/url-to-route',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'url' => 'sapiente',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/odit/core/url-to-route"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "url": "sapiente"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View frontend settings.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quasi/core/web/action-settings"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/quasi/core/web/action-settings');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quasi/core/web/action-settings"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

View frontend settings.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dolore/core/web/app-settings"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/dolore/core/web/app-settings');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolore/core/web/app-settings"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

View frontend settings.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/cum/core/web/settings/id"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/cum/core/web/settings/id');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/cum/core/web/settings/id"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Upload single.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/optio/file" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "storage_id": "nihil",
    "file": "blanditiis",
    "file_type": "ex",
    "item_type": "atque",
    "thumbnail_sizes": [
        "consequatur"
    ],
    "base64": "ut"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/optio/file',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'storage_id' => 'nihil',
            'file' => 'blanditiis',
            'file_type' => 'ex',
            'item_type' => 'atque',
            'thumbnail_sizes' => [
                'consequatur',
            ],
            'base64' => 'ut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/optio/file"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "storage_id": "nihil",
    "file": "blanditiis",
    "file_type": "ex",
    "item_type": "atque",
    "thumbnail_sizes": [
        "consequatur"
    ],
    "base64": "ut"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/file

URL Parameters

ver string

Body Parameters

storage_id string optional

file string

file_type string optional

item_type string optional

thumbnail_sizes string[] optional

base64 string optional

Upload multiple file.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/voluptas/files" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "storage_id": "sint",
    "item_type": "modi",
    "upload_type": "libero",
    "thumbnail_sizes": [
        "ut"
    ],
    "file": [
        "dolor"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/voluptas/files',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'storage_id' => 'sint',
            'item_type' => 'modi',
            'upload_type' => 'libero',
            'thumbnail_sizes' => [
                'ut',
            ],
            'file' => [
                'dolor',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/files"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "storage_id": "sint",
    "item_type": "modi",
    "upload_type": "libero",
    "thumbnail_sizes": [
        "ut"
    ],
    "file": [
        "dolor"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/files

URL Parameters

ver string

Body Parameters

storage_id string optional

0 string optional

item_type string optional

upload_type string optional

thumbnail_sizes string[] optional

file string[]

View link.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/provident/link/fetch" \
    --header "Content-Type: application/json" \
    --data "{
    "link": "ex",
    "owner_id": 20
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/provident/link/fetch',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'link' => 'ex',
            'owner_id' => 20,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/provident/link/fetch"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "link": "ex",
    "owner_id": 20
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/ping

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ratione/ping"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/ratione/ping');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ratione/ping"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

E-Wallet

App name: E-Wallet Version: 5.1.7 Author: phpFox Updated at: Aug 02, 2024

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/vel/emoney/request" \
    --header "Content-Type: application/json" \
    --data "{
    "from_date": "quos",
    "to_date": "omnis",
    "id": 14
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/vel/emoney/request',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'from_date' => 'quos',
            'to_date' => 'omnis',
            'id' => 14,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/vel/emoney/request"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "from_date": "quos",
    "to_date": "omnis",
    "id": 14
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/emoney/request/cancel/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/magni/emoney/request/cancel/1034212"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/magni/emoney/request/cancel/1034212');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/magni/emoney/request/cancel/1034212"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/emoney/request/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/atque/emoney/request/73"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/atque/emoney/request/73');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/atque/emoney/request/73"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

View item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/consequatur/emoney/statistic/3"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/consequatur/emoney/statistic/3');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consequatur/emoney/statistic/3"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/atque/emoney/transaction" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "sit",
    "base_currency": "esse",
    "from_date": "et",
    "to_date": "ut",
    "buyer": "in",
    "id": 7,
    "source": "error",
    "type": "magnam"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/atque/emoney/transaction',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'sit',
            'base_currency' => 'esse',
            'from_date' => 'et',
            'to_date' => 'ut',
            'buyer' => 'in',
            'id' => 7,
            'source' => 'error',
            'type' => 'magnam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/atque/emoney/transaction"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "sit",
    "base_currency": "esse",
    "from_date": "et",
    "to_date": "ut",
    "buyer": "in",
    "id": 7,
    "source": "error",
    "type": "magnam"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/emoney/transaction

URL Parameters

ver string

Body Parameters

q string optional

base_currency string optional

status string optional

from_date string optional

to_date string optional

buyer string optional

id integer optional

source string optional

type string optional

GET api/{ver}/emoney/transaction/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dolor/emoney/transaction/6410805"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/dolor/emoney/transaction/6410805');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolor/emoney/transaction/6410805"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Event

App name: Event Version: 5.0.18 Author: phpFox Updated at: Aug 02, 2024

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/animi/event" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "qui",
    "view": "vel",
    "sort": "voluptate",
    "sort_type": "dolor",
    "when": "est",
    "category_id": 2.8,
    "user_id": 21,
    "owner_id": 2,
    "event_id": 704.13,
    "page": 33,
    "where": "ehoibodusundfrdkxyplohsmiwqidrsmoz",
    "lat": 1714.12105342,
    "lng": 25604004.562,
    "radius": 73,
    "limit": 32591645.448726192,
    "is_online": 6.2,
    "is_featured": 277759.095,
    "bounds_west": 63220055.683261,
    "bounds_east": 41905.82402,
    "bounds_south": 179935.05809102,
    "bounds_north": 22.393
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/animi/event',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'qui',
            'view' => 'vel',
            'sort' => 'voluptate',
            'sort_type' => 'dolor',
            'when' => 'est',
            'category_id' => 2.8,
            'user_id' => 21.0,
            'owner_id' => 2,
            'event_id' => 704.13,
            'page' => 33,
            'where' => 'ehoibodusundfrdkxyplohsmiwqidrsmoz',
            'lat' => 1714.12105342,
            'lng' => 25604004.562,
            'radius' => 73,
            'limit' => 32591645.448726192,
            'is_online' => 6.2,
            'is_featured' => 277759.095,
            'bounds_west' => 63220055.683261,
            'bounds_east' => 41905.82402,
            'bounds_south' => 179935.05809102,
            'bounds_north' => 22.393,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/animi/event"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "qui",
    "view": "vel",
    "sort": "voluptate",
    "sort_type": "dolor",
    "when": "est",
    "category_id": 2.8,
    "user_id": 21,
    "owner_id": 2,
    "event_id": 704.13,
    "page": 33,
    "where": "ehoibodusundfrdkxyplohsmiwqidrsmoz",
    "lat": 1714.12105342,
    "lng": 25604004.562,
    "radius": 73,
    "limit": 32591645.448726192,
    "is_online": 6.2,
    "is_featured": 277759.095,
    "bounds_west": 63220055.683261,
    "bounds_east": 41905.82402,
    "bounds_south": 179935.05809102,
    "bounds_north": 22.393
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/event

URL Parameters

ver string

Body Parameters

q string optional

view string optional

sort string optional

sort_type string optional

when string optional

category_id number optional

user_id number optional

owner_id integer optional

event_id number optional

page number optional

Must be at least 1.

where string optional

Must be at least 2 characters.

lat number optional

lng number optional

radius number optional

Must be at least 1.

limit number optional

is_online number optional

is_featured number optional

bounds_west number optional

bounds_east number optional

bounds_south number optional

bounds_north number optional

Store a newly created resource in storage.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/ut/event" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "name": "perferendis",
    "text": "doloribus",
    "file": {
        "file_type": "veniam",
        "temp_file": 15493.16683673
    },
    "attachments": [
        "quia"
    ],
    "categories": [
        17.371062
    ],
    "owner_id": 1424335.72417,
    "is_online": 22291,
    "event_url": "http:\/\/www.renner.com\/eaque-nam-magnam-aut-eveniet-alias",
    "start_time": "2022-12-31",
    "end_time": "2074-10-28",
    "privacy": "sit",
    "image_position": "quod",
    "location_name": "enim"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/ut/event',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'perferendis',
            'text' => 'doloribus',
            'file' => [
                'file_type' => 'veniam',
                'temp_file' => 15493.16683673,
            ],
            'attachments' => [
                'quia',
            ],
            'categories' => [
                17.371062,
            ],
            'owner_id' => 1424335.72417,
            'is_online' => 22291.0,
            'event_url' => 'http://www.renner.com/eaque-nam-magnam-aut-eveniet-alias',
            'start_time' => '2022-12-31',
            'end_time' => '2074-10-28',
            'privacy' => 'sit',
            'image_position' => 'quod',
            'location_name' => 'enim',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/event"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "perferendis",
    "text": "doloribus",
    "file": {
        "file_type": "veniam",
        "temp_file": 15493.16683673
    },
    "attachments": [
        "quia"
    ],
    "categories": [
        17.371062
    ],
    "owner_id": 1424335.72417,
    "is_online": 22291,
    "event_url": "http:\/\/www.renner.com\/eaque-nam-magnam-aut-eveniet-alias",
    "start_time": "2022-12-31",
    "end_time": "2074-10-28",
    "privacy": "sit",
    "image_position": "quod",
    "location_name": "enim"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/event

URL Parameters

ver string

Body Parameters

name string

text string optional

file object optional

file.file_type string optional

This field is required when file is present.

file.temp_file number optional

This field is required when file is present.

attachments number[] optional

attachments[].id number optional

attachments[].status string optional

categories number[] optional

owner_id number optional

is_online number

event_url string optional

This field is required when is_online is 1. Must be a valid URL.

start_time string

Must be a valid date. Must be a date before end_time.

end_time string

Must be a valid date. Must be a date after start_time.

privacy string

host object optional

image_position string optional

location_name string optional

This field is required when is_online is 0.

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quo/event-category" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 6991.161503,
    "page": 15,
    "q": "cumque",
    "level": 42594839.51371666,
    "limit": 20
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quo/event-category',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 6991.161503,
            'page' => 15,
            'q' => 'cumque',
            'level' => 42594839.51371666,
            'limit' => 20,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quo/event-category"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 6991.161503,
    "page": 15,
    "q": "cumque",
    "level": 42594839.51371666,
    "limit": 20
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/event-category

URL Parameters

ver string

Body Parameters

id number optional

page number optional

Must be at least 1.

q string optional

level number optional

limit number optional

Must be at least 10.

POST api/{ver}/event-code

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/veniam/event-code" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "event_id": 58795.87,
    "refresh": 8
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/veniam/event-code',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'event_id' => 58795.87,
            'refresh' => 8,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/veniam/event-code"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "event_id": 58795.87,
    "refresh": 8
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/event-code/accept/{code}

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/sunt/event-code/accept/dolores" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/sunt/event-code/accept/dolores',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sunt/event-code/accept/dolores"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/event-code/verify/{code}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ut/event-code/verify/quis" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ut/event-code/verify/quis',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/event-code/verify/quis"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/event-host-invite

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/neque/event-host-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "event_id": 71478743.0773,
    "accept": 3.7
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/neque/event-host-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'event_id' => 71478743.0773,
            'accept' => 3.7,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/neque/event-host-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "event_id": 71478743.0773,
    "accept": 3.7
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/perspiciatis/event-host-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "event_id": 350264333.9470264,
    "user_id": "saepe"
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/perspiciatis/event-host-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'event_id' => 350264333.9470264,
            'user_id' => 'saepe',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/perspiciatis/event-host-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "event_id": 350264333.9470264,
    "user_id": "saepe"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/event-host-invite

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/distinctio/event-host-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "event_id": 0.89702481,
    "page": 9,
    "limit": 500293.97796568
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/distinctio/event-host-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'event_id' => 0.89702481,
            'page' => 9,
            'limit' => 500293.97796568,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/distinctio/event-host-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "event_id": 0.89702481,
    "page": 9,
    "limit": 500293.97796568
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Store a newly created resource in storage.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/voluptatem/event-host-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "event_id": 3938286.4,
    "user_ids": [
        28988.9627
    ],
    "users": [
        "id"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/voluptatem/event-host-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'event_id' => 3938286.4,
            'user_ids' => [
                28988.9627,
            ],
            'users' => [
                'id',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatem/event-host-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "event_id": 3938286.4,
    "user_ids": [
        28988.9627
    ],
    "users": [
        "id"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/event-host-invite

URL Parameters

ver string

Body Parameters

event_id number

user_ids number[] optional

users number[] optional

users[].id number optional

PUT api/{ver}/event-invite

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/iusto/event-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "event_id": 9609.5,
    "accept": 186.285
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/iusto/event-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'event_id' => 9609.5,
            'accept' => 186.285,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/iusto/event-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "event_id": 9609.5,
    "accept": 186.285
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/soluta/event-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "event_id": 2233.58997,
    "user_id": "delectus"
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/soluta/event-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'event_id' => 2233.58997,
            'user_id' => 'delectus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/soluta/event-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "event_id": 2233.58997,
    "user_id": "delectus"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/event-invite

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quo/event-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "event_id": 36.03567891,
    "page": 15,
    "limit": 416514507
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quo/event-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'event_id' => 36.03567891,
            'page' => 15,
            'limit' => 416514507.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quo/event-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "event_id": 36.03567891,
    "page": 15,
    "limit": 416514507
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Store a newly created resource in storage.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/et/event-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "event_id": 827173,
    "user_ids": [
        5.71
    ],
    "users": [
        "maxime"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/et/event-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'event_id' => 827173.0,
            'user_ids' => [
                5.71,
            ],
            'users' => [
                'maxime',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/event-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "event_id": 827173,
    "user_ids": [
        5.71
    ],
    "users": [
        "maxime"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/event-invite

URL Parameters

ver string

Body Parameters

event_id number

user_ids number[] optional

users number[] optional

users[].id number optional

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/et/event-member" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "event_id": 34655.82099,
    "view": "eum",
    "page": 1,
    "limit": 1387.447110144
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/et/event-member',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'event_id' => 34655.82099,
            'view' => 'eum',
            'page' => 1,
            'limit' => 1387.447110144,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/event-member"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "event_id": 34655.82099,
    "view": "eum",
    "page": 1,
    "limit": 1387.447110144
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/event-member

URL Parameters

ver string

Body Parameters

q string optional

event_id number

view string optional

page number optional

Must be at least 1.

limit number optional

Store a newly created resource in storage.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/quas/event-member" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "event_id": 4324.44,
    "invite_code": "labore"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/quas/event-member',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'event_id' => 4324.44,
            'invite_code' => 'labore',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quas/event-member"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "event_id": 4324.44,
    "invite_code": "labore"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/event-member/host

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/quas/event-member/host" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "event_id": 3066616.836,
    "user_id": 33113717.37549371
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/quas/event-member/host',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'event_id' => 3066616.836,
            'user_id' => 33113717.37549371,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quas/event-member/host"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "event_id": 3066616.836,
    "user_id": 33113717.37549371
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/event-member/interest/{id}

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/ut/event-member/interest/4" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "interest": 483721640.42838,
    "invite_code": "aliquid"
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/ut/event-member/interest/4',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'interest' => 483721640.42838,
            'invite_code' => 'aliquid',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/event-member/interest/4"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "interest": 483721640.42838,
    "invite_code": "aliquid"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/event-member/interest/{id}

URL Parameters

ver string

id string

The ID of the interest.

Body Parameters

interest number

invite_code string optional

DELETE api/{ver}/event-member/member

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/et/event-member/member" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "event_id": 2874213.3052567,
    "user_id": 708536014
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/et/event-member/member',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'event_id' => 2874213.3052567,
            'user_id' => 708536014.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/event-member/member"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "event_id": 2874213.3052567,
    "user_id": 708536014
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/et/event-member/834" \
    --header "Authorization: Bearer {accessToken}" \

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/et/event-member/834',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/event-member/834"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/event/approve/{id}

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/itaque/event/approve/30274" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/itaque/event/approve/30274',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/itaque/event/approve/30274"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/event/banner/{id}

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/laboriosam/event/banner/0" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "temp_file": 690.802488096,
    "position": "nam"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/laboriosam/event/banner/0',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'temp_file' => 690.802488096,
            'position' => 'nam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/laboriosam/event/banner/0"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "temp_file": 690.802488096,
    "position": "nam"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/event/banner/{id}

URL Parameters

ver string

id string

The ID of the banner.

Body Parameters

image string optional

temp_file number optional

position string optional

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/a/event/banner/23" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/a/event/banner/23',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/a/event/banner/23"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/event/feature/{id}

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/excepturi/event/feature/5" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "0"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/excepturi/event/feature/5',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '0',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/excepturi/event/feature/5"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "0"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aut/event/setting/form/223935" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aut/event/setting/form/223935',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/event/setting/form/223935"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/event/setting/{id}

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/quae/event/setting/3" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "pending_mode": 14.55148536
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/quae/event/setting/3',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'pending_mode' => 14.55148536,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quae/event/setting/3"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "pending_mode": 14.55148536
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/nulla/event/sponsor-in-feed/58" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": 2638527.986
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/nulla/event/sponsor-in-feed/58',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 2638527.986,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nulla/event/sponsor-in-feed/58"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": 2638527.986
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/id/event/sponsor/0" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "et"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/id/event/sponsor/0',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/id/event/sponsor/0"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "et"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display the specified resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/veniam/event/262" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "invite_code": "accusantium"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/veniam/event/262',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'invite_code' => 'accusantium',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/veniam/event/262"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "invite_code": "accusantium"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/sequi/event/51854" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/sequi/event/51854',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sequi/event/51854"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/event/{id}/export

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/iusto/event/7721/export" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/iusto/event/7721/export',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/iusto/event/7721/export"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/event/{id}/mass-email

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/ipsam/event/1/mass-email" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "subject": "consequatur",
    "text": "esse"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/ipsam/event/1/mass-email',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'subject' => 'consequatur',
            'text' => 'esse',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ipsam/event/1/mass-email"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "subject": "consequatur",
    "text": "esse"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/event/{id}/mass-invite

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/cum/event/9/mass-invite" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/cum/event/9/mass-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/cum/event/9/mass-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/event/{id}/stats

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/fuga/event/28096883/stats" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/fuga/event/28096883/stats',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/fuga/event/28096883/stats"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Featured

App name: Featured Version: 5.0.2 Author: phpFox Updated at: Aug 02, 2024

Browse item

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dignissimos/featured/invoice" \
    --header "Content-Type: application/json" \
    --data "{
    "item_type": "aliquid",
    "package_id": 12,
    "payment_gateway": 8,
    "from_date": "2024-08-02T08:10:39",
    "to_date": "2024-08-02T08:10:39",
    "limit": 20,
    "id": 74,
    "transaction_id": "ullam",
    "q": "rerum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/dignissimos/featured/invoice',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_type' => 'aliquid',
            'package_id' => 12,
            'payment_gateway' => 8,
            'from_date' => '2024-08-02T08:10:39',
            'to_date' => '2024-08-02T08:10:39',
            'limit' => 20,
            'id' => 74,
            'transaction_id' => 'ullam',
            'q' => 'rerum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dignissimos/featured/invoice"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_type": "aliquid",
    "package_id": 12,
    "payment_gateway": 8,
    "from_date": "2024-08-02T08:10:39",
    "to_date": "2024-08-02T08:10:39",
    "limit": 20,
    "id": 74,
    "transaction_id": "ullam",
    "q": "rerum"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/featured/invoice

URL Parameters

ver string

Body Parameters

item_type string optional

package_id integer optional

status string optional

payment_gateway integer optional

from_date string optional

Must be a valid date.

to_date string optional

Must be a valid date.

limit integer optional

Must be at least 1. Must not be greater than 50.

id integer optional

Must be at least 1.

transaction_id string optional

q string optional

POST api/{ver}/featured/invoice/payment

Example request:

curl --request POST \
    "http://localhost/api/v1/api/hic/featured/invoice/payment" \
    --header "Content-Type: application/json" \
    --data "{
    "payment_gateway": 11,
    "invoice_id": 6298.221
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/hic/featured/invoice/payment',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'payment_gateway' => 11,
            'invoice_id' => 6298.221,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/hic/featured/invoice/payment"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "payment_gateway": 11,
    "invoice_id": 6298.221
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/featured/invoice/{id}/cancel

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/deserunt/featured/invoice/13/cancel"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/deserunt/featured/invoice/13/cancel');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/deserunt/featured/invoice/13/cancel"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/featured/invoice/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/tempore/featured/invoice/2"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/tempore/featured/invoice/2');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/tempore/featured/invoice/2"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Browse item

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/fuga/featured/item" \
    --header "Content-Type: application/json" \
    --data "{
    "item_type": "saepe",
    "package_id": 11,
    "from_date": "2024-08-02T08:10:39",
    "to_date": "2024-08-02T08:10:39",
    "limit": 16,
    "id": 19
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/fuga/featured/item',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_type' => 'saepe',
            'package_id' => 11,
            'from_date' => '2024-08-02T08:10:39',
            'to_date' => '2024-08-02T08:10:39',
            'limit' => 16,
            'id' => 19,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/fuga/featured/item"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_type": "saepe",
    "package_id": 11,
    "from_date": "2024-08-02T08:10:39",
    "to_date": "2024-08-02T08:10:39",
    "limit": 16,
    "id": 19
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/featured/item

URL Parameters

ver string

Body Parameters

item_type string optional

package_id integer optional

status string optional

from_date string optional

Must be a valid date.

to_date string optional

Must be a valid date.

limit integer optional

Must be at least 1. Must not be greater than 50.

package_duration_period string optional

id integer optional

pricing string optional

Store item

Example request:

curl --request POST \
    "http://localhost/api/v1/api/quidem/featured/item" \
    --header "Content-Type: application/json" \
    --data "{
    "item_type": "aut",
    "item_id": 24,
    "package_id": 5
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/quidem/featured/item',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_type' => 'aut',
            'item_id' => 24,
            'package_id' => 5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quidem/featured/item"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_type": "aut",
    "item_id": 24,
    "package_id": 5
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/featured/item/form/{item_type}/{item_id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/adipisci/featured/item/form/et/blanditiis"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/adipisci/featured/item/form/et/blanditiis');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/adipisci/featured/item/form/et/blanditiis"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/featured/item/{id}/cancel

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/quam/featured/item/1/cancel"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/quam/featured/item/1/cancel');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quam/featured/item/1/cancel"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/featured/item/{id}/payment-form

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/et/featured/item/0718347/payment-form"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/et/featured/item/0718347/payment-form');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/featured/item/0718347/payment-form"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/featured/item/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aliquam/featured/item/5"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/aliquam/featured/item/5');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aliquam/featured/item/5"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/featured/item/{id}

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/omnis/featured/item/1876033"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/omnis/featured/item/1876033');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/omnis/featured/item/1876033"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

Browse item

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/minima/featured/package" \
    --header "Content-Type: application/json" \
    --data "{
    "view": "nam",
    "q": "tenetur"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/minima/featured/package',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'view' => 'nam',
            'q' => 'tenetur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/minima/featured/package"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "view": "nam",
    "q": "tenetur"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Feed

App name: Feed Version: 5.0.22 Author: phpFox Updated at: Aug 02, 2024

Browse feed item.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ullam/feed" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "aliquid",
    "page": 39,
    "limit": 10307758,
    "user_id": 51,
    "item_id": 2281670.05976825,
    "item_type": "sapiente",
    "last_feed_id": 14252145.01119792,
    "related_comment_friend_only": "0",
    "view": "odit",
    "from": "deleniti",
    "type_id": "fugit",
    "sort": "deleniti",
    "sort_type": "minus",
    "status": "sunt",
    "sponsored_feed_ids": [
        60
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ullam/feed',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'aliquid',
            'page' => 39,
            'limit' => 10307758.0,
            'user_id' => 51,
            'item_id' => 2281670.05976825,
            'item_type' => 'sapiente',
            'last_feed_id' => 14252145.01119792,
            'related_comment_friend_only' => '0',
            'view' => 'odit',
            'from' => 'deleniti',
            'type_id' => 'fugit',
            'sort' => 'deleniti',
            'sort_type' => 'minus',
            'status' => 'sunt',
            'sponsored_feed_ids' => [
                60,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ullam/feed"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "aliquid",
    "page": 39,
    "limit": 10307758,
    "user_id": 51,
    "item_id": 2281670.05976825,
    "item_type": "sapiente",
    "last_feed_id": 14252145.01119792,
    "related_comment_friend_only": "0",
    "view": "odit",
    "from": "deleniti",
    "type_id": "fugit",
    "sort": "deleniti",
    "sort_type": "minus",
    "status": "sunt",
    "sponsored_feed_ids": [
        60
    ]
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/feed

URL Parameters

ver string

Body Parameters

q string optional

page number optional

Must be at least 1.

limit number optional

user_id integer optional

Must be at least 1.

item_id number optional

item_type string optional

hashtag string optional

last_feed_id number optional

related_comment_friend_only string optional

Must be one of 0 or 1.

view string optional

from string optional

type_id string optional

sort string optional

sort_type string optional

status string optional

is_preview_tag string optional

has_pin_post string optional

sponsored_feed_ids integer[] optional

Must be at least 1.

Create feed.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/eveniet/feed" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "post_type": "aut",
    "status_background_id": 64,
    "schedule_time": "2024-08-02T08:10:39",
    "location": {
        "address": "quia",
        "lat": 643.46530166,
        "lng": 44352.8403896
    },
    "tagged_friends": [
        2544.6
    ],
    "tagged_in_photo": [
        {
            "friend_id": 0,
            "px": 3050.518,
            "py": 874720.002554
        }
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/eveniet/feed',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'post_type' => 'aut',
            'status_background_id' => 64,
            'schedule_time' => '2024-08-02T08:10:39',
            'location' => [
                'address' => 'quia',
                'lat' => 643.46530166,
                'lng' => 44352.8403896,
            ],
            'tagged_friends' => [
                2544.6,
            ],
            'tagged_in_photo' => [
                [
                    'friend_id' => 0.0,
                    'px' => 3050.518,
                    'py' => 874720.002554,
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eveniet/feed"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "post_type": "aut",
    "status_background_id": 64,
    "schedule_time": "2024-08-02T08:10:39",
    "location": {
        "address": "quia",
        "lat": 643.46530166,
        "lng": 44352.8403896
    },
    "tagged_friends": [
        2544.6
    ],
    "tagged_in_photo": [
        {
            "friend_id": 0,
            "px": 3050.518,
            "py": 874720.002554
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/feed

URL Parameters

ver string

Body Parameters

post_type string

privacy string optional

status_background_id number optional

Must be at least 1.

parent_item_id string optional

post_as_parent string optional

user_status string optional

schedule_time string optional

Must be a valid date.

location object optional

location.address string optional

location.lat number optional

location.lng number optional

tagged_friends number[] optional

tagged_in_photo object[] optional

tagged_in_photo[].friend_id number optional

tagged_in_photo[].px number optional

tagged_in_photo[].py number optional

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/magni/feed-schedule" \
    --header "Content-Type: application/json" \
    --data "{
    "entity_id": 54,
    "entity_type": "provident",
    "page": 67,
    "limit": 14
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/magni/feed-schedule',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'entity_id' => 54,
            'entity_type' => 'provident',
            'page' => 67,
            'limit' => 14,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/magni/feed-schedule"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "entity_id": 54,
    "entity_type": "provident",
    "page": 67,
    "limit": 14
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/feed-schedule

URL Parameters

ver string

Body Parameters

entity_id integer optional

Must be at least 1.

entity_type string optional

page integer optional

Must be at least 1.

limit integer optional

GET api/{ver}/feed-schedule/edit/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/facere/feed-schedule/edit/98647"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/facere/feed-schedule/edit/98647');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/facere/feed-schedule/edit/98647"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/feed-schedule/send-now/{id}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/sapiente/feed-schedule/send-now/183"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/sapiente/feed-schedule/send-now/183');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sapiente/feed-schedule/send-now/183"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

View item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/similique/feed-schedule/70"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/similique/feed-schedule/70');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/similique/feed-schedule/70"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Update item.

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/in/feed-schedule/735" \
    --header "Content-Type: application/json" \
    --data "{
    "post_type": "aut",
    "status_background_id": 77,
    "schedule_time": "2024-08-02T08:10:39",
    "location": {
        "address": "dolorem",
        "lat": 78082035.9,
        "lng": 1
    },
    "tagged_friends": [
        209.584
    ],
    "tagged_in_photo": [
        {
            "friend_id": 12.87,
            "px": 720856.4452892,
            "py": 60141320.85268389
        }
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/in/feed-schedule/735',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'post_type' => 'aut',
            'status_background_id' => 77,
            'schedule_time' => '2024-08-02T08:10:39',
            'location' => [
                'address' => 'dolorem',
                'lat' => 78082035.9,
                'lng' => 1.0,
            ],
            'tagged_friends' => [
                209.584,
            ],
            'tagged_in_photo' => [
                [
                    'friend_id' => 12.87,
                    'px' => 720856.4452892,
                    'py' => 60141320.85268389,
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/in/feed-schedule/735"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "post_type": "aut",
    "status_background_id": 77,
    "schedule_time": "2024-08-02T08:10:39",
    "location": {
        "address": "dolorem",
        "lat": 78082035.9,
        "lng": 1
    },
    "tagged_friends": [
        209.584
    ],
    "tagged_in_photo": [
        {
            "friend_id": 12.87,
            "px": 720856.4452892,
            "py": 60141320.85268389
        }
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/feed-schedule/{id}

PATCH api/{ver}/feed-schedule/{id}

URL Parameters

ver string

id string

The ID of the feed schedule.

Body Parameters

post_type string

privacy string optional

status_background_id number optional

Must be at least 1.

parent_item_id string optional

post_as_parent string optional

user_status string optional

schedule_time string

Must be a valid date.

location object optional

location.address string optional

location.lat number optional

location.lng number optional

tagged_friends number[] optional

tagged_in_photo object[] optional

tagged_in_photo[].friend_id number optional

tagged_in_photo[].px number optional

tagged_in_photo[].py number optional

Delete item.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/ea/feed-schedule/3779"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/ea/feed-schedule/3779');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ea/feed-schedule/3779"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/feed-schedule/{feed_schedule}/edit

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/adipisci/feed-schedule/nemo/edit"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/adipisci/feed-schedule/nemo/edit');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/adipisci/feed-schedule/nemo/edit"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/feed/allow-preview/{id}

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/enim/feed/allow-preview/2411" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "is_allowed": "esse"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/enim/feed/allow-preview/2411',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'is_allowed' => 'esse',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/enim/feed/allow-preview/2411"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "is_allowed": "esse"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Approve pending post.

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/et/feed/approve/026" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/et/feed/approve/026',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/feed/approve/026"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/feed/archive/{id}

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/placeat/feed/archive/07406" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/placeat/feed/archive/07406',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/placeat/feed/archive/07406"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/feed/check-new

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/nihil/feed/check-new" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "last_feed_id": 34261.789,
    "last_pin_feed_id": 15371.669415319,
    "last_sponsored_feed_id": 7.84,
    "sort": "necessitatibus"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/nihil/feed/check-new',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'last_feed_id' => 34261.789,
            'last_pin_feed_id' => 15371.669415319,
            'last_sponsored_feed_id' => 7.84,
            'sort' => 'necessitatibus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nihil/feed/check-new"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "last_feed_id": 34261.789,
    "last_pin_feed_id": 15371.669415319,
    "last_sponsored_feed_id": 7.84,
    "sort": "necessitatibus"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/feed/check-new

URL Parameters

ver string

Body Parameters

last_feed_id number optional

last_pin_feed_id number optional

last_sponsored_feed_id number optional

sort string optional

hot fix because of /api/v1/feed/create crashed.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/consequatur/feed/create" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/consequatur/feed/create',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consequatur/feed/create"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/feed/decline/{id}

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/qui/feed/decline/0" \
    --header "Authorization: Bearer {accessToken}" \

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/qui/feed/decline/0',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/feed/decline/0"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Request

PATCH api/{ver}/feed/decline/{id}

URL Parameters

ver string

id string

The ID of the decline.

Body Parameters

is_block_author string optional

delete_activities string optional

Get status for edit.

requires authentication

GET: feed/edit/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/facere/feed/edit/25312" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/facere/feed/edit/25312',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/facere/feed/edit/25312"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Browse snooze.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quo/feed/hidden" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": 73,
    "page": 29,
    "limit": 0.0901,
    "type": "group",
    "q": "quis"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quo/feed/hidden',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 73,
            'page' => 29,
            'limit' => 0.0901,
            'type' => 'group',
            'q' => 'quis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quo/feed/hidden"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 73,
    "page": 29,
    "limit": 0.0901,
    "type": "group",
    "q": "quis"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/feed/hidden

URL Parameters

ver string

Body Parameters

user_id number optional

Must be at least 1.

page number optional

Must be at least 1.

limit number optional

type string optional

Must be one of friend, page, or group.

q string optional

Remove snooze.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/laudantium/feed/hidden/1888872" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/laudantium/feed/hidden/1888872',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/laudantium/feed/hidden/1888872"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Hide a user.

requires authentication

POST: feed/hide-all/{id}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/veniam/feed/hide-all/7" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/veniam/feed/hide-all/7',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/veniam/feed/hide-all/7"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

UnHide a user.

requires authentication

DELETE: feed/hide-all/{id}

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/sint/feed/hide-all/3679" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/sint/feed/hide-all/3679',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sint/feed/hide-all/3679"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Hide a feed.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/dicta/feed/hide-feed/536" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/dicta/feed/hide-feed/536',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dicta/feed/hide-feed/536"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Un-Hide a feed.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/nostrum/feed/hide-feed/659411" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/nostrum/feed/hide-feed/659411',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nostrum/feed/hide-feed/659411"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/labore/feed/history/5470396"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/labore/feed/history/5470396');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/labore/feed/history/5470396"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/feed/items/{id}

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/ipsum/feed/items/3" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/ipsum/feed/items/3',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ipsum/feed/items/3"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Pin a feed.

requires authentication

POST: feed/pin/{id}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/eum/feed/pin/3" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "owner_id": 15
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/eum/feed/pin/3',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'owner_id' => 15,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eum/feed/pin/3"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "owner_id": 15
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Pin a feed.

requires authentication

POST: feed/pin/{id}/home

Example request:

curl --request POST \
    "http://localhost/api/v1/api/blanditiis/feed/pin/4/home" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/blanditiis/feed/pin/4/home',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/blanditiis/feed/pin/4/home"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Unpin a feed.

requires authentication

DELETE: feed/pin/{id}/home

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/quis/feed/pin/53/home" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/quis/feed/pin/53/home',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quis/feed/pin/53/home"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Get post types.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/qui/feed/post-type" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/qui/feed/post-type',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/feed/post-type"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Update feed privacy.

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/tempore/feed/privacy/42333" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "privacy": "nisi"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/tempore/feed/privacy/42333',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'privacy' => 'nisi',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/tempore/feed/privacy/42333"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "privacy": "nisi"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/odio/feed/share" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "user_status": "dolor",
    "post_type": "fugiat",
    "item_id": 34188.853,
    "item_type": "ad",
    "context_item_id": 226.22,
    "context_item_type": "voluptas",
    "type_id": "voluptatem",
    "post_content": "cumque",
    "parent_feed_id": 102.1083,
    "location": {
        "address": "veritatis",
        "lat": 2.13181136,
        "lng": 547071.24372161
    },
    "tagged_friends": [
        56.7
    ],
    "tagged_in_photo": [
        {
            "friend_id": 475527,
            "px": 68.18796,
            "py": 9.2814
        }
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/odio/feed/share',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_status' => 'dolor',
            'post_type' => 'fugiat',
            'item_id' => 34188.853,
            'item_type' => 'ad',
            'context_item_id' => 226.22,
            'context_item_type' => 'voluptas',
            'type_id' => 'voluptatem',
            'post_content' => 'cumque',
            'parent_feed_id' => 102.1083,
            'location' => [
                'address' => 'veritatis',
                'lat' => 2.13181136,
                'lng' => 547071.24372161,
            ],
            'tagged_friends' => [
                56.7,
            ],
            'tagged_in_photo' => [
                [
                    'friend_id' => 475527.0,
                    'px' => 68.18796,
                    'py' => 9.2814,
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/odio/feed/share"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_status": "dolor",
    "post_type": "fugiat",
    "item_id": 34188.853,
    "item_type": "ad",
    "context_item_id": 226.22,
    "context_item_type": "voluptas",
    "type_id": "voluptatem",
    "post_content": "cumque",
    "parent_feed_id": 102.1083,
    "location": {
        "address": "veritatis",
        "lat": 2.13181136,
        "lng": 547071.24372161
    },
    "tagged_friends": [
        56.7
    ],
    "tagged_in_photo": [
        {
            "friend_id": 475527,
            "px": 68.18796,
            "py": 9.2814
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/feed/share

URL Parameters

ver string

Body Parameters

user_status string optional

post_type string optional

item_id number

item_type string

context_item_id number optional

context_item_type string optional

type_id string optional

post_content string optional

parent_feed_id number optional

privacy string optional

location object optional

location.address string optional

location.lat number optional

location.lng number optional

tagged_friends number[] optional

tagged_in_photo object[] optional

tagged_in_photo[].friend_id number optional

tagged_in_photo[].px number optional

tagged_in_photo[].py number optional

requires authentication

GET: feed/share/form

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quod/feed/share/form" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quod/feed/share/form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quod/feed/share/form"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Snooze a user.

requires authentication

POST: feed/snooze/{id}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/ab/feed/snooze/283" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/ab/feed/snooze/283',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ab/feed/snooze/283"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Un-Snooze a user.

requires authentication

DELETE: feed/snooze/{id}

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/et/feed/snooze/8" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/et/feed/snooze/8',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/feed/snooze/8"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Remove tag.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/dolorum/feed/tag/927" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/dolorum/feed/tag/927',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolorum/feed/tag/927"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Get tagged friends.

requires authentication

GET: /feed/tagged-friend

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/tempore/feed/tagged-friend" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 36,
    "limit": 45602.4309473,
    "item_id": 45.50206,
    "item_type": "impedit"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/tempore/feed/tagged-friend',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 36,
            'limit' => 45602.4309473,
            'item_id' => 45.50206,
            'item_type' => 'impedit',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/tempore/feed/tagged-friend"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 36,
    "limit": 45602.4309473,
    "item_id": 45.50206,
    "item_type": "impedit"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/feed/tagged-friend

URL Parameters

ver string

Body Parameters

page number optional

Must be at least 1.

limit number optional

item_id number

item_type string

excluded_ids object optional

GET api/{ver}/feed/translate

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ea/feed/translate" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 8,
    "target": "consequatur"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ea/feed/translate',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 8,
            'target' => 'consequatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ea/feed/translate"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 8,
    "target": "consequatur"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Unpin a feed.

requires authentication

DELETE: feed/unpin/{id}

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/corrupti/feed/unpin/0" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "owner_id": 20
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/corrupti/feed/unpin/0',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'owner_id' => 20,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/corrupti/feed/unpin/0"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "owner_id": 20
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View feed item.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/est/feed/0588" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/est/feed/0588',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/est/feed/0588"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Update feed item.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/quaerat/feed/64" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "post_type": "error",
    "status_background_id": 35,
    "parent_item_id": 9,
    "location": {
        "address": "dolores",
        "lat": 345455290.6534,
        "lng": 190352914.7922
    },
    "tagged_in_photo": [
        {
            "friend_id": 26016203.79277713,
            "px": 1846.147068751,
            "py": 18479559.86063
        }
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/quaerat/feed/64',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'post_type' => 'error',
            'status_background_id' => 35,
            'parent_item_id' => 9,
            'location' => [
                'address' => 'dolores',
                'lat' => 345455290.6534,
                'lng' => 190352914.7922,
            ],
            'tagged_in_photo' => [
                [
                    'friend_id' => 26016203.79277713,
                    'px' => 1846.147068751,
                    'py' => 18479559.86063,
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quaerat/feed/64"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "post_type": "error",
    "status_background_id": 35,
    "parent_item_id": 9,
    "location": {
        "address": "dolores",
        "lat": 345455290.6534,
        "lng": 190352914.7922
    },
    "tagged_in_photo": [
        {
            "friend_id": 26016203.79277713,
            "px": 1846.147068751,
            "py": 18479559.86063
        }
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/feed/{id}

PATCH api/{ver}/feed/{id}

URL Parameters

ver string

id string

The ID of the feed.

Body Parameters

post_type string

privacy string optional

status_background_id number optional

Must be at least 0.

parent_item_id integer optional

user_status string optional

location object optional

location.address string optional

location.lat number optional

location.lng number optional

tagged_friends string[] optional

tagged_in_photo object[] optional

tagged_in_photo[].friend_id number optional

tagged_in_photo[].px number optional

tagged_in_photo[].py number optional

Delete feed item.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/qui/feed/551" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/qui/feed/551',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/feed/551"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Follow

App name: Follow Version: 5.0.11 Author: phpFox Updated at: Aug 02, 2024

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/nam/follow" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "qui",
    "view": "dolor",
    "user_id": 76563.06952054,
    "page": 62,
    "limit": 556931.095
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/nam/follow',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'qui',
            'view' => 'dolor',
            'user_id' => 76563.06952054,
            'page' => 62,
            'limit' => 556931.095,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nam/follow"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "qui",
    "view": "dolor",
    "user_id": 76563.06952054,
    "page": 62,
    "limit": 556931.095
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/follow

URL Parameters

ver string

Body Parameters

q string optional

view string optional

user_id number optional

This field is required when view is following.

page number optional

Must be at least 1.

limit number optional

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/tempore/follow" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": 9532.7497
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/tempore/follow',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 9532.7497,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/tempore/follow"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9532.7497
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Delete item.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/temporibus/follow/7"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/temporibus/follow/7');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/temporibus/follow/7"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

Forum

App name: Forum Version: 5.0.20 Author: phpFox Updated at: Aug 02, 2024

GET api/{ver}/forum

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/unde/forum" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": 6963324.071,
    "view": "numquam",
    "forum_id": 73.8,
    "q": "accusamus",
    "sort": "dolor",
    "sort_thread": "delectus",
    "sort_post": "expedita",
    "sort_type": "natus",
    "when": "enim",
    "item_type": "et",
    "page": 4,
    "limit": 9191526.3605,
    "parent_id": 89.964
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/unde/forum',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 6963324.071,
            'view' => 'numquam',
            'forum_id' => 73.8,
            'q' => 'accusamus',
            'sort' => 'dolor',
            'sort_thread' => 'delectus',
            'sort_post' => 'expedita',
            'sort_type' => 'natus',
            'when' => 'enim',
            'item_type' => 'et',
            'page' => 4,
            'limit' => 9191526.3605,
            'parent_id' => 89.964,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/unde/forum"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 6963324.071,
    "view": "numquam",
    "forum_id": 73.8,
    "q": "accusamus",
    "sort": "dolor",
    "sort_thread": "delectus",
    "sort_post": "expedita",
    "sort_type": "natus",
    "when": "enim",
    "item_type": "et",
    "page": 4,
    "limit": 9191526.3605,
    "parent_id": 89.964
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/forum

URL Parameters

ver string

Body Parameters

user_id number optional

view string optional

forum_id number optional

q string optional

sort string optional

sort_thread string optional

sort_post string optional

sort_type string optional

when string optional

item_type string optional

page number optional

Must be at least 1.

limit number optional

parent_id number optional

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/minima/forum-post" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": 26061131.605906792,
    "q": "ut",
    "view": "nulla",
    "sort": "nisi",
    "sort_type": "et",
    "when": "vero",
    "thread_id": 312.72,
    "post_id": 27473.9965103,
    "forum_id": 39664.34952468,
    "page": 23,
    "limit": 100.353389
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/minima/forum-post',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 26061131.605906792,
            'q' => 'ut',
            'view' => 'nulla',
            'sort' => 'nisi',
            'sort_type' => 'et',
            'when' => 'vero',
            'thread_id' => 312.72,
            'post_id' => 27473.9965103,
            'forum_id' => 39664.34952468,
            'page' => 23,
            'limit' => 100.353389,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/minima/forum-post"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 26061131.605906792,
    "q": "ut",
    "view": "nulla",
    "sort": "nisi",
    "sort_type": "et",
    "when": "vero",
    "thread_id": 312.72,
    "post_id": 27473.9965103,
    "forum_id": 39664.34952468,
    "page": 23,
    "limit": 100.353389
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/forum-post

URL Parameters

ver string

Body Parameters

user_id number optional

q string optional

view string optional

sort string optional

sort_type string optional

when string optional

thread_id number optional

post_id number optional

forum_id number optional

page number optional

Must be at least 1.

limit number optional

Store a newly created resource in storage.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/laudantium/forum-post" \
    --header "Content-Type: application/json" \
    --data "{
    "thread_id": 7.470201,
    "owner_id": 3382396.4002575865,
    "text": "qui",
    "attachments": [
        "non"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/laudantium/forum-post',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'thread_id' => 7.470201,
            'owner_id' => 3382396.4002575865,
            'text' => 'qui',
            'attachments' => [
                'non',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/laudantium/forum-post"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "thread_id": 7.470201,
    "owner_id": 3382396.4002575865,
    "text": "qui",
    "attachments": [
        "non"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/forum-post

URL Parameters

ver string

Body Parameters

thread_id number

owner_id number optional

text string

attachments number[] optional

attachments[].id number optional

attachments[].status string optional

captcha string optional

PATCH api/{ver}/forum-post/approve/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/consequatur/forum-post/approve/096"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/consequatur/forum-post/approve/096');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consequatur/forum-post/approve/096"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/forum-post/form/{id?}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/omnis/forum-post/form/8" \
    --header "Content-Type: application/json" \
    --data "{
    "owner_id": 99136.5332,
    "thread_id": 29430.104
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/omnis/forum-post/form/8',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'owner_id' => 99136.5332,
            'thread_id' => 29430.104,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/omnis/forum-post/form/8"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "owner_id": 99136.5332,
    "thread_id": 29430.104
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/forum-post/posters

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/nam/forum-post/posters" \
    --header "Content-Type: application/json" \
    --data "{
    "thread_id": "voluptatum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/nam/forum-post/posters',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'thread_id' => 'voluptatum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nam/forum-post/posters"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "thread_id": "voluptatum"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/forum-post/quote

Example request:

curl --request POST \
    "http://localhost/api/v1/api/quidem/forum-post/quote" \
    --header "Content-Type: application/json" \
    --data "{
    "quote_id": 3049223.87595,
    "text": "debitis",
    "attachments": [
        "eum"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/quidem/forum-post/quote',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'quote_id' => 3049223.87595,
            'text' => 'debitis',
            'attachments' => [
                'eum',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quidem/forum-post/quote"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "quote_id": 3049223.87595,
    "text": "debitis",
    "attachments": [
        "eum"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/forum-post/quote

URL Parameters

ver string

Body Parameters

quote_id number

text string

attachments number[] optional

attachments[].id number optional

attachments[].status string optional

captcha string optional

GET api/{ver}/forum-post/quote/form/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ullam/forum-post/quote/form/1"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/ullam/forum-post/quote/form/1');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ullam/forum-post/quote/form/1"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Display the specified resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/eos/forum-post/7"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/eos/forum-post/7');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eos/forum-post/7"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Update the specified resource in storage.

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/veritatis/forum-post/33574202" \
    --header "Content-Type: application/json" \
    --data "{
    "text": "error",
    "attachments": [
        "in"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/veritatis/forum-post/33574202',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'text' => 'error',
            'attachments' => [
                'in',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/veritatis/forum-post/33574202"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "text": "error",
    "attachments": [
        "in"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/forum-post/{id}

PATCH api/{ver}/forum-post/{id}

URL Parameters

ver string

id string

The ID of the forum post.

Body Parameters

text string optional

attachments number[] optional

attachments[].id number optional

attachments[].status string optional

captcha string optional

Remove the specified resource from storage.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/velit/forum-post/475"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/velit/forum-post/475');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/velit/forum-post/475"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/forum-subs/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/nobis/forum-subs/514"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/nobis/forum-subs/514');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nobis/forum-subs/514"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/occaecati/forum-thread" \
    --header "Content-Type: application/json" \
    --data "{
    "owner_id": 7,
    "user_id": 834.07,
    "q": "doloremque",
    "view": "et",
    "sort": "excepturi",
    "sort_type": "quos",
    "when": "enim",
    "forum_id": 590342,
    "page": 32,
    "limit": 7862314.03273653
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/occaecati/forum-thread',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'owner_id' => 7,
            'user_id' => 834.07,
            'q' => 'doloremque',
            'view' => 'et',
            'sort' => 'excepturi',
            'sort_type' => 'quos',
            'when' => 'enim',
            'forum_id' => 590342.0,
            'page' => 32,
            'limit' => 7862314.03273653,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/occaecati/forum-thread"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "owner_id": 7,
    "user_id": 834.07,
    "q": "doloremque",
    "view": "et",
    "sort": "excepturi",
    "sort_type": "quos",
    "when": "enim",
    "forum_id": 590342,
    "page": 32,
    "limit": 7862314.03273653
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/forum-thread

URL Parameters

ver string

Body Parameters

owner_id integer optional

user_id number optional

q string optional

view string optional

sort string optional

sort_type string optional

when string optional

forum_id number optional

page number optional

Must be at least 1.

limit number optional

PATCH api/{ver}/forum-thread/approve/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/culpa/forum-thread/approve/7"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/culpa/forum-thread/approve/7');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/culpa/forum-thread/approve/7"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/forum-thread/close/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/culpa/forum-thread/close/75" \
    --header "Content-Type: application/json" \
    --data "{
    "is_closed": "quod"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/culpa/forum-thread/close/75',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'is_closed' => 'quod',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/culpa/forum-thread/close/75"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "is_closed": "quod"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/forum-thread/copy

Example request:

curl --request POST \
    "http://localhost/api/v1/api/quasi/forum-thread/copy" \
    --header "Content-Type: application/json" \
    --data "{
    "forum_id": 101231211,
    "title": "jhgl",
    "thread_id": 434.95787773
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/quasi/forum-thread/copy',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'forum_id' => 101231211.0,
            'title' => 'jhgl',
            'thread_id' => 434.95787773,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quasi/forum-thread/copy"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "forum_id": 101231211,
    "title": "jhgl",
    "thread_id": 434.95787773
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/forum-thread/copy/form/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/excepturi/forum-thread/copy/form/090"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/excepturi/forum-thread/copy/form/090');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/excepturi/forum-thread/copy/form/090"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/forum-thread/last-read/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/eligendi/forum-thread/last-read/31" \
    --header "Content-Type: application/json" \
    --data "{
    "post_id": 79
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/eligendi/forum-thread/last-read/31',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'post_id' => 79,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eligendi/forum-thread/last-read/31"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "post_id": 79
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/forum-thread/merge

Example request:

curl --request POST \
    "http://localhost/api/v1/api/dolor/forum-thread/merge" \
    --header "Content-Type: application/json" \
    --data "{
    "forum_id": 343018.0711471,
    "current_thread_id": 4330585.199,
    "merged_thread_id": 3718159.7223221
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/dolor/forum-thread/merge',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'forum_id' => 343018.0711471,
            'current_thread_id' => 4330585.199,
            'merged_thread_id' => 3718159.7223221,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolor/forum-thread/merge"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "forum_id": 343018.0711471,
    "current_thread_id": 4330585.199,
    "merged_thread_id": 3718159.7223221
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/forum-thread/merge/form/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/excepturi/forum-thread/merge/form/8294"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/excepturi/forum-thread/merge/form/8294');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/excepturi/forum-thread/merge/form/8294"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/forum-thread/move/form/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/recusandae/forum-thread/move/form/390499"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/recusandae/forum-thread/move/form/390499');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/recusandae/forum-thread/move/form/390499"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/forum-thread/move/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/eaque/forum-thread/move/3" \
    --header "Content-Type: application/json" \
    --data "{
    "forum_id": 0.920296
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/eaque/forum-thread/move/3',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'forum_id' => 0.920296,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eaque/forum-thread/move/3"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "forum_id": 0.920296
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/et/forum-thread/sponsor-in-feed/5" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": 5641508.6
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/et/forum-thread/sponsor-in-feed/5',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 5641508.6,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/forum-thread/sponsor-in-feed/5"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": 5641508.6
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/voluptas/forum-thread/sponsor/5974" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "praesentium"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/voluptas/forum-thread/sponsor/5974',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'praesentium',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/forum-thread/sponsor/5974"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "praesentium"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/forum-thread/stick/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/itaque/forum-thread/stick/3" \
    --header "Content-Type: application/json" \
    --data "{
    "is_sticked": "laborum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/itaque/forum-thread/stick/3',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'is_sticked' => 'laborum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/itaque/forum-thread/stick/3"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "is_sticked": "laborum"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/unde/forum-thread/subscribe/31" \
    --header "Content-Type: application/json" \
    --data "{
    "is_subscribed": "voluptatum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/unde/forum-thread/subscribe/31',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'is_subscribed' => 'voluptatum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/unde/forum-thread/subscribe/31"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "is_subscribed": "voluptatum"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/forum-thread/suggestion-search

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ut/forum-thread/suggestion-search" \
    --header "Content-Type: application/json" \
    --data "{
    "owner_id": 13,
    "user_id": 397915.1,
    "q": "autem",
    "view": "perferendis",
    "sort": "saepe",
    "sort_type": "dolor",
    "when": "voluptas",
    "forum_id": 2.7047635,
    "page": 22,
    "limit": 507054200.7,
    "exclude_thread_ids": "laudantium"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ut/forum-thread/suggestion-search',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'owner_id' => 13,
            'user_id' => 397915.1,
            'q' => 'autem',
            'view' => 'perferendis',
            'sort' => 'saepe',
            'sort_type' => 'dolor',
            'when' => 'voluptas',
            'forum_id' => 2.7047635,
            'page' => 22,
            'limit' => 507054200.7,
            'exclude_thread_ids' => 'laudantium',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/forum-thread/suggestion-search"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "owner_id": 13,
    "user_id": 397915.1,
    "q": "autem",
    "view": "perferendis",
    "sort": "saepe",
    "sort_type": "dolor",
    "when": "voluptas",
    "forum_id": 2.7047635,
    "page": 22,
    "limit": 507054200.7,
    "exclude_thread_ids": "laudantium"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/forum-thread/suggestion-search

URL Parameters

ver string

Body Parameters

owner_id integer optional

user_id number optional

q string optional

view string optional

sort string optional

sort_type string optional

when string optional

forum_id number optional

page number optional

Must be at least 1.

limit number optional

exclude_thread_ids string optional

Display the specified resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/illum/forum-thread/05"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/illum/forum-thread/05');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/illum/forum-thread/05"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Remove the specified resource from storage.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/nulla/forum-thread/631040"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/nulla/forum-thread/631040');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nulla/forum-thread/631040"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/forum/option

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aut/forum/option" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": 25866.4,
    "view": "quibusdam",
    "forum_id": 24321.291102786,
    "q": "culpa",
    "sort": "praesentium",
    "sort_thread": "magnam",
    "sort_post": "reprehenderit",
    "sort_type": "nobis",
    "when": "quasi",
    "item_type": "sequi",
    "page": 50,
    "limit": 2541.4,
    "parent_id": 16.52290182
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aut/forum/option',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 25866.4,
            'view' => 'quibusdam',
            'forum_id' => 24321.291102786,
            'q' => 'culpa',
            'sort' => 'praesentium',
            'sort_thread' => 'magnam',
            'sort_post' => 'reprehenderit',
            'sort_type' => 'nobis',
            'when' => 'quasi',
            'item_type' => 'sequi',
            'page' => 50,
            'limit' => 2541.4,
            'parent_id' => 16.52290182,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/forum/option"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 25866.4,
    "view": "quibusdam",
    "forum_id": 24321.291102786,
    "q": "culpa",
    "sort": "praesentium",
    "sort_thread": "magnam",
    "sort_post": "reprehenderit",
    "sort_type": "nobis",
    "when": "quasi",
    "item_type": "sequi",
    "page": 50,
    "limit": 2541.4,
    "parent_id": 16.52290182
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/forum/option

URL Parameters

ver string

Body Parameters

user_id number optional

view string optional

forum_id number optional

q string optional

sort string optional

sort_thread string optional

sort_post string optional

sort_type string optional

when string optional

item_type string optional

page number optional

Must be at least 1.

limit number optional

parent_id number optional

GET api/{ver}/forum/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ipsum/forum/3849"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/ipsum/forum/3849');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ipsum/forum/3849"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Friend

App name: Friend Version: 5.0.18 Author: phpFox Updated at: Aug 02, 2024

Browse friends.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/corrupti/friend" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "consequatur",
    "view": "friend",
    "sort": "inventore",
    "sort_type": "numquam",
    "when": "aut",
    "list_id": 0,
    "user_id": 210007163.363483,
    "page": 12,
    "limit": 531771451,
    "owner_id": 26892.7,
    "is_featured": 3169447.4502
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/corrupti/friend',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'consequatur',
            'view' => 'friend',
            'sort' => 'inventore',
            'sort_type' => 'numquam',
            'when' => 'aut',
            'list_id' => 0.0,
            'user_id' => 210007163.363483,
            'page' => 12,
            'limit' => 531771451.0,
            'owner_id' => 26892.7,
            'is_featured' => 3169447.4502,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/corrupti/friend"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "consequatur",
    "view": "friend",
    "sort": "inventore",
    "sort_type": "numquam",
    "when": "aut",
    "list_id": 0,
    "user_id": 210007163.363483,
    "page": 12,
    "limit": 531771451,
    "owner_id": 26892.7,
    "is_featured": 3169447.4502
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/friend

URL Parameters

ver string

Body Parameters

q string optional

view string optional

Must be one of mutual, latest, friend, profile, or search.

sort string optional

sort_type string optional

when string optional

list_id number optional

user_id number optional

This field is required when view is mutual or profile.

page number optional

Must be at least 1.

limit number optional

owner_id number optional

share_on_profile string optional

is_member_only string optional

is_featured number optional

Get birthday.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/tenetur/friend/birthday" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 32,
    "month": 82,
    "view": "est",
    "limit": 64.523573
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/tenetur/friend/birthday',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 32,
            'month' => 82,
            'view' => 'est',
            'limit' => 64.523573,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/tenetur/friend/birthday"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 32,
    "month": 82,
    "view": "est",
    "limit": 64.523573
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/friend/birthday

URL Parameters

ver string

Body Parameters

page number optional

Must be at least 1.

month number optional

Must be at least 1.

view string optional

limit number optional

GET api/{ver}/friend/invite-to-item

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aut/friend/invite-to-item" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "owner_id": 387791.715,
    "user_id": 12.39,
    "item_type": "dicta",
    "item_id": 117.2477,
    "q": "modi"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aut/friend/invite-to-item',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'owner_id' => 387791.715,
            'user_id' => 12.39,
            'item_type' => 'dicta',
            'item_id' => 117.2477,
            'q' => 'modi',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/friend/invite-to-item"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "owner_id": 387791.715,
    "user_id": 12.39,
    "item_type": "dicta",
    "item_id": 117.2477,
    "q": "modi"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/friend/invite-to-item

URL Parameters

ver string

Body Parameters

owner_id number

user_id number optional

item_type string

item_id number

q string optional

Invite friend.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ratione/friend/invite-to-owner" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "autem",
    "privacy_type": "in",
    "owner_id": 93.05004,
    "page": 5,
    "limit": 783165518,
    "parent_id": 9454268
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ratione/friend/invite-to-owner',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'autem',
            'privacy_type' => 'in',
            'owner_id' => 93.05004,
            'page' => 5,
            'limit' => 783165518.0,
            'parent_id' => 9454268.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ratione/friend/invite-to-owner"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "autem",
    "privacy_type": "in",
    "owner_id": 93.05004,
    "page": 5,
    "limit": 783165518,
    "parent_id": 9454268
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/friend/invite-to-owner

URL Parameters

ver string

Body Parameters

q string optional

privacy_type string

owner_id number

page number optional

Must be at least 1.

limit number optional

parent_id number optional

Browse friend lists.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/eaque/friend/list" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 90,
    "limit": 15.0607,
    "sort": "in",
    "sort_type": "sed"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/eaque/friend/list',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 90,
            'limit' => 15.0607,
            'sort' => 'in',
            'sort_type' => 'sed',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eaque/friend/list"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 90,
    "limit": 15.0607,
    "sort": "in",
    "sort_type": "sed"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/friend/list

URL Parameters

ver string

Body Parameters

page number optional

Must be at least 1.

limit number optional

sort string optional

sort_type string optional

Add friend list.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/distinctio/friend/list/add-friend/3" \
    --header "Authorization: Bearer {accessToken}" \

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/distinctio/friend/list/add-friend/3',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/distinctio/friend/list/add-friend/3"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/friend/list/add-friend/{id}

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/necessitatibus/friend/list/add-friend/4" \
    --header "Authorization: Bearer {accessToken}" \

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/necessitatibus/friend/list/add-friend/4',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/necessitatibus/friend/list/add-friend/4"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Assign friend to list.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptatem/friend/list/assign/2" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptatem/friend/list/assign/2',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatem/friend/list/assign/2"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Assign multiple friend to list.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/provident/friend/list/assign/61423040" \
    --header "Authorization: Bearer {accessToken}" \

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/provident/friend/list/assign/61423040',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/provident/friend/list/assign/61423040"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/friend/list/create

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aliquam/friend/list/create" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aliquam/friend/list/create',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aliquam/friend/list/create"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

View friend list.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quaerat/friend/list/496" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quaerat/friend/list/496',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quaerat/friend/list/496"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Remove friend list.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/sint/friend/list/57" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/sint/friend/list/57',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sint/friend/list/57"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/friend/list/{list}/edit

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/incidunt/friend/list/porro/edit" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/incidunt/friend/list/porro/edit',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/incidunt/friend/list/porro/edit"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Load mentions.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/distinctio/friend/mention" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "dolorem",
    "view": "friend",
    "sort": "provident",
    "sort_type": "est",
    "when": "dolores",
    "list_id": 0.1901,
    "user_id": 0.352929,
    "page": 45,
    "limit": 52959601.3242,
    "owner_id": 6289088.1,
    "is_featured": 0
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/distinctio/friend/mention',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'dolorem',
            'view' => 'friend',
            'sort' => 'provident',
            'sort_type' => 'est',
            'when' => 'dolores',
            'list_id' => 0.1901,
            'user_id' => 0.352929,
            'page' => 45,
            'limit' => 52959601.3242,
            'owner_id' => 6289088.1,
            'is_featured' => 0.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/distinctio/friend/mention"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "dolorem",
    "view": "friend",
    "sort": "provident",
    "sort_type": "est",
    "when": "dolores",
    "list_id": 0.1901,
    "user_id": 0.352929,
    "page": 45,
    "limit": 52959601.3242,
    "owner_id": 6289088.1,
    "is_featured": 0
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/friend/mention

URL Parameters

ver string

Body Parameters

q string optional

view string optional

Must be one of mutual, latest, friend, profile, or search.

sort string optional

sort_type string optional

when string optional

list_id number optional

user_id number optional

This field is required when view is mutual or profile.

page number optional

Must be at least 1.

limit number optional

owner_id number optional

share_on_profile string optional

is_member_only string optional

is_featured number optional

Browse friend request.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/tempore/friend/request" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "view": "provident",
    "page": 82,
    "limit": 4960.19448
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/tempore/friend/request',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'view' => 'provident',
            'page' => 82,
            'limit' => 4960.19448,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/tempore/friend/request"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "view": "provident",
    "page": 82,
    "limit": 4960.19448
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Create friend request.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/possimus/friend/request" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "friend_user_id": 387.3856461
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/possimus/friend/request',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'friend_user_id' => 387.3856461,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/possimus/friend/request"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "friend_user_id": 387.3856461
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Mark all as read.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/a/friend/request/markAllAsRead" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/a/friend/request/markAllAsRead',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/a/friend/request/markAllAsRead"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Update friend request.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/labore/friend/request/8" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "action": "a"
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/labore/friend/request/8',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'action' => 'a',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/labore/friend/request/8"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "action": "a"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Remove friend request.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/ex/friend/request/795" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/ex/friend/request/795',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ex/friend/request/795"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/eveniet/friend/share-suggestion" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "voluptates",
    "view": "friend",
    "sort": "nam",
    "sort_type": "dolore",
    "when": "odit",
    "list_id": 8.9,
    "user_id": 259.6349606,
    "page": 86,
    "limit": 2666.0963635,
    "owner_id": 8562.3071509,
    "is_featured": 35278.1769
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/eveniet/friend/share-suggestion',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'voluptates',
            'view' => 'friend',
            'sort' => 'nam',
            'sort_type' => 'dolore',
            'when' => 'odit',
            'list_id' => 8.9,
            'user_id' => 259.6349606,
            'page' => 86,
            'limit' => 2666.0963635,
            'owner_id' => 8562.3071509,
            'is_featured' => 35278.1769,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eveniet/friend/share-suggestion"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "voluptates",
    "view": "friend",
    "sort": "nam",
    "sort_type": "dolore",
    "when": "odit",
    "list_id": 8.9,
    "user_id": 259.6349606,
    "page": 86,
    "limit": 2666.0963635,
    "owner_id": 8562.3071509,
    "is_featured": 35278.1769
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Load suggestion.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sint/friend/suggestion" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 30,
    "limit": 1292754
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sint/friend/suggestion',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 30,
            'limit' => 1292754.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sint/friend/suggestion"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 30,
    "limit": 1292754
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Hide user suggestions.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/qui/friend/suggestion/hide" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": 70411033.6
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/qui/friend/suggestion/hide',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 70411033.6,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/friend/suggestion/hide"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 70411033.6
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Load friend suggestion for tagging.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/nulla/friend/tag-suggestion" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "et",
    "page": 54,
    "limit": 56025254.7050469,
    "item_id": 6868.991,
    "item_type": "ut",
    "owner_id": 11389948.2,
    "excluded_ids": [
        36.5
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/nulla/friend/tag-suggestion',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'et',
            'page' => 54,
            'limit' => 56025254.7050469,
            'item_id' => 6868.991,
            'item_type' => 'ut',
            'owner_id' => 11389948.2,
            'excluded_ids' => [
                36.5,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nulla/friend/tag-suggestion"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "et",
    "page": 54,
    "limit": 56025254.7050469,
    "item_id": 6868.991,
    "item_type": "ut",
    "owner_id": 11389948.2,
    "excluded_ids": [
        36.5
    ]
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/friend/tag-suggestion

URL Parameters

ver string

Body Parameters

q string optional

page number optional

Must be at least 1.

limit number optional

item_id number optional

item_type string optional

owner_id number optional

excluded_ids number[] optional

Remove friend.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/libero/friend/894" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/libero/friend/894',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/libero/friend/894"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Group

App name: Group Version: 5.0.22 Author: phpFox Updated at: Aug 02, 2024

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ducimus/group" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "aut",
    "view": "aut",
    "sort": "quo",
    "sort_type": "fugiat",
    "when": "dolores",
    "type_id": 445503,
    "category_id": 15915643.7824549,
    "owner_id": 14,
    "user_id": 4.3139,
    "is_featured": 722.937310798,
    "page": 5,
    "limit": 1677117.1305
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ducimus/group',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'aut',
            'view' => 'aut',
            'sort' => 'quo',
            'sort_type' => 'fugiat',
            'when' => 'dolores',
            'type_id' => 445503.0,
            'category_id' => 15915643.7824549,
            'owner_id' => 14,
            'user_id' => 4.3139,
            'is_featured' => 722.937310798,
            'page' => 5,
            'limit' => 1677117.1305,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ducimus/group"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "aut",
    "view": "aut",
    "sort": "quo",
    "sort_type": "fugiat",
    "when": "dolores",
    "type_id": 445503,
    "category_id": 15915643.7824549,
    "owner_id": 14,
    "user_id": 4.3139,
    "is_featured": 722.937310798,
    "page": 5,
    "limit": 1677117.1305
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/group

URL Parameters

ver string

Body Parameters

q string optional

view string optional

sort string optional

sort_type string optional

when string optional

type_id number optional

category_id number optional

owner_id integer optional

user_id number optional

is_featured number optional

page number optional

Must be at least 1.

limit number optional

Store a newly created resource in storage.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/repellendus/group" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "name": "est",
    "category_id": 383970.448334,
    "reg_method": 35107.085158391,
    "text": "facere",
    "users": [
        "dolor"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/repellendus/group',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'est',
            'category_id' => 383970.448334,
            'reg_method' => 35107.085158391,
            'text' => 'facere',
            'users' => [
                'dolor',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/repellendus/group"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "est",
    "category_id": 383970.448334,
    "reg_method": 35107.085158391,
    "text": "facere",
    "users": [
        "dolor"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/group

URL Parameters

ver string

Body Parameters

name string

category_id number optional

reg_method number

text string optional

users number[] optional

users[].id number optional

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/iure/group-announcement" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 99.809941,
    "page": 39,
    "limit": 61.0495
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/iure/group-announcement',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 99.809941,
            'page' => 39,
            'limit' => 61.0495,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/iure/group-announcement"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 99.809941,
    "page": 39,
    "limit": 61.0495
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/quisquam/group-announcement" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 2.4576,
    "item_id": 549.45,
    "item_type": "saepe"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/quisquam/group-announcement',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 2.4576,
            'item_id' => 549.45,
            'item_type' => 'saepe',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quisquam/group-announcement"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 2.4576,
    "item_id": 549.45,
    "item_type": "saepe"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Delete item.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/ea/group-announcement" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 586.68624109,
    "item_id": 2445,
    "item_type": "ea"
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/ea/group-announcement',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 586.68624109,
            'item_id' => 2445.0,
            'item_type' => 'ea',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ea/group-announcement"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 586.68624109,
    "item_id": 2445,
    "item_type": "ea"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/group-announcement/hide

Example request:

curl --request POST \
    "http://localhost/api/v1/api/et/group-announcement/hide" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 35209587.9667589,
    "ann_id": 2843691.09978
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/et/group-announcement/hide',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 35209587.9667589,
            'ann_id' => 2843691.09978,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/group-announcement/hide"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 35209587.9667589,
    "ann_id": 2843691.09978
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Browse item

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sequi/group-block" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 79.6,
    "q": "sequi",
    "page": 41,
    "limit": 6.7744
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sequi/group-block',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 79.6,
            'q' => 'sequi',
            'page' => 41,
            'limit' => 6.7744,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sequi/group-block"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 79.6,
    "q": "sequi",
    "page": 41,
    "limit": 6.7744
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Store item

Example request:

curl --request POST \
    "http://localhost/api/v1/api/magni/group-block" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 955,
    "user_id": 40911.807457,
    "delete_activities": 36622865
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/magni/group-block',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 955.0,
            'user_id' => 40911.807457,
            'delete_activities' => 36622865.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/magni/group-block"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 955,
    "user_id": 40911.807457,
    "delete_activities": 36622865
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display the specified resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/consequuntur/group-info/1792715" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "invite_code": "aut"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/consequuntur/group-info/1792715',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'invite_code' => 'aut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consequuntur/group-info/1792715"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "invite_code": "aut"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Reorder example rule.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/atque/group-integrated/order" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 1.3289
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/atque/group-integrated/order',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 1.3289,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/atque/group-integrated/order"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 1.3289
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Update item.

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/et/group-integrated/1"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/et/group-integrated/1');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/group-integrated/1"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

Browse group invitation.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/repudiandae/group-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 734133.15505,
    "q": "inventore",
    "page": 42,
    "limit": 180.86
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/repudiandae/group-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 734133.15505,
            'q' => 'inventore',
            'page' => 42,
            'limit' => 180.86,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/repudiandae/group-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 734133.15505,
    "q": "inventore",
    "page": 42,
    "limit": 180.86
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/group-invite

URL Parameters

ver string

Body Parameters

group_id number

q string optional

page number optional

Must be at least 1.

limit number optional

Store group invitation.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/eos/group-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 509412.9,
    "user_ids": []
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/eos/group-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 509412.9,
            'user_ids' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eos/group-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 509412.9,
    "user_ids": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Update group invitation.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/et/group-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 5243494.6137936,
    "invite_code": "ea",
    "accept": 4.12663
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/et/group-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 5243494.6137936,
            'invite_code' => 'ea',
            'accept' => 4.12663,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/group-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 5243494.6137936,
    "invite_code": "ea",
    "accept": 4.12663
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Remove group invitation.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/aperiam/group-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 5.5915017,
    "user_id": "fuga"
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/aperiam/group-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 5.5915017,
            'user_id' => 'fuga',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aperiam/group-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 5.5915017,
    "user_id": "fuga"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Browse group members.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dolorum/group-member" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "vel",
    "group_id": 251836.91,
    "view": "quo",
    "page": 8,
    "limit": 198477936.8464,
    "not_invite_role": 25081934,
    "excluded_user_id": 954
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/dolorum/group-member',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'vel',
            'group_id' => 251836.91,
            'view' => 'quo',
            'page' => 8,
            'limit' => 198477936.8464,
            'not_invite_role' => 25081934.0,
            'excluded_user_id' => 954.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolorum/group-member"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "vel",
    "group_id": 251836.91,
    "view": "quo",
    "page": 8,
    "limit": 198477936.8464,
    "not_invite_role": 25081934,
    "excluded_user_id": 954
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/group-member

URL Parameters

ver string

Body Parameters

q string optional

group_id number

view string optional

page number optional

Must be at least 1.

limit number optional

not_invite_role number optional

excluded_user_id number optional

Create group member.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/at/group-member" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 0.1764
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/at/group-member',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 0.1764,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/at/group-member"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 0.1764
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Add group admin.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/expedita/group-member/add-group-admin" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 0.91349265,
    "user_ids": [
        1.18522
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/expedita/group-member/add-group-admin',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 0.91349265,
            'user_ids' => [
                1.18522,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/expedita/group-member/add-group-admin"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 0.91349265,
    "user_ids": [
        1.18522
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Add group moderators.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/ut/group-member/add-group-moderator" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 13325079.836494,
    "user_ids": [
        2457.5268638
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/ut/group-member/add-group-moderator',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 13325079.836494,
            'user_ids' => [
                2457.5268638,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/group-member/add-group-moderator"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 13325079.836494,
    "user_ids": [
        2457.5268638
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/group-member/cancel-invite

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/at/group-member/cancel-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 41.68,
    "user_id": 1187.2799,
    "invite_type": "error"
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/at/group-member/cancel-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 41.68,
            'user_id' => 1187.2799,
            'invite_type' => 'error',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/at/group-member/cancel-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 41.68,
    "user_id": 1187.2799,
    "invite_type": "error"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Change to moderator.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/aut/group-member/change-to-moderator" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 73717,
    "user_id": 26.98
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/aut/group-member/change-to-moderator',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 73717.0,
            'user_id' => 26.98,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/group-member/change-to-moderator"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 73717,
    "user_id": 26.98
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Reassign group owner.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/accusamus/group-member/reassign-owner" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 38662.209,
    "user_id": 1.1086678,
    "users": [
        "reiciendis"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/accusamus/group-member/reassign-owner',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 38662.209,
            'user_id' => 1.1086678,
            'users' => [
                'reiciendis',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/accusamus/group-member/reassign-owner"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 38662.209,
    "user_id": 1.1086678,
    "users": [
        "reiciendis"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/group-member/reassign-owner

URL Parameters

ver string

Body Parameters

group_id number

user_id number optional

This field is required when users is not present.

users number[] optional

users[].id number optional

This field is required when users is present.

Remove group admin.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/repudiandae/group-member/remove-group-admin" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 291.34093,
    "user_id": 4763.051702,
    "is_delete": 0.6386
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/repudiandae/group-member/remove-group-admin',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 291.34093,
            'user_id' => 4763.051702,
            'is_delete' => 0.6386,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/repudiandae/group-member/remove-group-admin"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 291.34093,
    "user_id": 4763.051702,
    "is_delete": 0.6386
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Delete group member.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/et/group-member/remove-group-member" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 226.704286945,
    "user_id": 889759.255,
    "delete_activities": 60.23693107
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/et/group-member/remove-group-member',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 226.704286945,
            'user_id' => 889759.255,
            'delete_activities' => 60.23693107,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/group-member/remove-group-member"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 226.704286945,
    "user_id": 889759.255,
    "delete_activities": 60.23693107
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Remove group moderator.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/voluptas/group-member/remove-group-moderator" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 5244.981,
    "user_id": 801.671,
    "is_delete": 173427612.5927
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/voluptas/group-member/remove-group-moderator',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 5244.981,
            'user_id' => 801.671,
            'is_delete' => 173427612.5927,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/group-member/remove-group-moderator"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 5244.981,
    "user_id": 801.671,
    "is_delete": 173427612.5927
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Delete group member.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/iste/group-member/4681" \
    --header "Authorization: Bearer {accessToken}" \

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/iste/group-member/4681',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/iste/group-member/4681"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Request

DELETE api/{ver}/group-member/{id}

URL Parameters

ver string

id string

The ID of the group member.

Body Parameters

not_invite_again string optional

reassign_owner_id string optional

Delete item.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/harum/group-mute" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 44661720.925,
    "user_id": 458076.7273528
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/harum/group-mute',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 44661720.925,
            'user_id' => 458076.7273528,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/harum/group-mute"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 44661720.925,
    "user_id": 458076.7273528
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptas/group-mute" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "reprehenderit",
    "group_id": 25922622,
    "limit": 198551.324
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptas/group-mute',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'reprehenderit',
            'group_id' => 25922622.0,
            'limit' => 198551.324,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/group-mute"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "reprehenderit",
    "group_id": 25922622,
    "limit": 198551.324
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/explicabo/group-mute" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 24653,
    "user_id": 436014,
    "expired_at": "eius"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/explicabo/group-mute',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 24653.0,
            'user_id' => 436014.0,
            'expired_at' => 'eius',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/explicabo/group-mute"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 24653,
    "user_id": 436014,
    "expired_at": "eius"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Browse Question.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aliquid/group-question" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 23.576453866,
    "page": 40,
    "limit": 19
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aliquid/group-question',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 23.576453866,
            'page' => 40,
            'limit' => 19.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aliquid/group-question"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 23.576453866,
    "page": 40,
    "limit": 19
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Store a question.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/sit/group-question" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 73973328.2,
    "question": "quae",
    "type_id": 25730933.3850621,
    "options": [
        "quisquam"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/sit/group-question',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 73973328.2,
            'question' => 'quae',
            'type_id' => 25730933.3850621,
            'options' => [
                'quisquam',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sit/group-question"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 73973328.2,
    "question": "quae",
    "type_id": 25730933.3850621,
    "options": [
        "quisquam"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/group-question

URL Parameters

ver string

Body Parameters

group_id number

question string

type_id number

options string[] optional

This field is required unless type_id is in 0.

options[].title string optional

This field is required unless type_id is in 0.

options[].status string optional

Get answer form.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/maxime/group-question/answer-form/9948" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/maxime/group-question/answer-form/9948',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/maxime/group-question/answer-form/9948"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Get creation form.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/numquam/group-question/form/16" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 427407.50266959
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/numquam/group-question/form/16',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 427407.50266959,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/numquam/group-question/form/16"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 427407.50266959
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Update question.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/nobis/group-question/76" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "question": "molestiae",
    "type_id": 11291994.067,
    "options": [
        "quia"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/nobis/group-question/76',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'question' => 'molestiae',
            'type_id' => 11291994.067,
            'options' => [
                'quia',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nobis/group-question/76"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "question": "molestiae",
    "type_id": 11291994.067,
    "options": [
        "quia"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/group-question/{id}

PATCH api/{ver}/group-question/{id}

URL Parameters

ver string

id string

The ID of the group question.

Body Parameters

question string optional

type_id number optional

options number[] optional

This field is required unless type_id is in 0.

options[].id number optional

options[].status string optional

options[].title string optional

This field is required unless options.*.status is in remove.

Remove question.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/repellendus/group-question/82383" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/repellendus/group-question/82383',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/repellendus/group-question/82383"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Browse member requests in a group.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/laudantium/group-request" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 30650935.333390065,
    "q": "magni",
    "view": "ipsum",
    "status": 3691.8,
    "start_date": "possimus",
    "end_date": "2119-06-21",
    "page": 45,
    "limit": 138024535.46111116
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/laudantium/group-request',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 30650935.333390065,
            'q' => 'magni',
            'view' => 'ipsum',
            'status' => 3691.8,
            'start_date' => 'possimus',
            'end_date' => '2119-06-21',
            'page' => 45,
            'limit' => 138024535.46111116,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/laudantium/group-request"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 30650935.333390065,
    "q": "magni",
    "view": "ipsum",
    "status": 3691.8,
    "start_date": "possimus",
    "end_date": "2119-06-21",
    "page": 45,
    "limit": 138024535.46111116
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/group-request

URL Parameters

ver string

Body Parameters

group_id number

q string optional

view string optional

status number optional

start_date string optional

end_date string optional

Must be a date after start_date.

page number optional

Must be at least 1.

limit number optional

Accept member request.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/assumenda/group-request/accept-request" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 3.9689,
    "user_id": 0.6704529
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/assumenda/group-request/accept-request',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 3.9689,
            'user_id' => 0.6704529,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/assumenda/group-request/accept-request"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 3.9689,
    "user_id": 0.6704529
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Cancel a member request.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/ab/group-request/cancel-request/7" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/ab/group-request/cancel-request/7',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ab/group-request/cancel-request/7"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Deny member request.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/dolor/group-request/deny-request" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 659791890.4251697,
    "user_id": 5643.23503108
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/dolor/group-request/deny-request',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 659791890.4251697,
            'user_id' => 5643.23503108,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolor/group-request/deny-request"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 659791890.4251697,
    "user_id": 5643.23503108
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Browse group rules.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sed/group-rule" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 4381983.820509522,
    "page": 73,
    "limit": 5098.7318
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sed/group-rule',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 4381983.820509522,
            'page' => 73,
            'limit' => 5098.7318,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sed/group-rule"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 4381983.820509522,
    "page": 73,
    "limit": 5098.7318
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Create group rule.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/consequuntur/group-rule" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 336.15533,
    "title": "qh",
    "description": "Qui aut optio iusto et cupiditate mollitia."
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/consequuntur/group-rule',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 336.15533,
            'title' => 'qh',
            'description' => 'Qui aut optio iusto et cupiditate mollitia.',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consequuntur/group-rule"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 336.15533,
    "title": "qh",
    "description": "Qui aut optio iusto et cupiditate mollitia."
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/group-rule

URL Parameters

ver string

Body Parameters

group_id number

title string

Must be between 1 and 255 characters.

description string optional

Must be between 1 and 500 characters.

Browse example rules.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/in/group-rule-example" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/in/group-rule-example',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/in/group-rule-example"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

View creation form.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/laudantium/group-rule/form" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 90376316.72
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/laudantium/group-rule/form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 90376316.72,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/laudantium/group-rule/form"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 90376316.72
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View update form.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ducimus/group-rule/form/437" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ducimus/group-rule/form/437',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ducimus/group-rule/form/437"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Reorder rules.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/autem/group-rule/order" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "orders": [
        13.5574
    ],
    "group_id": 1343.062198
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/autem/group-rule/order',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'orders' => [
                13.5574,
            ],
            'group_id' => 1343.062198,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/autem/group-rule/order"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "orders": [
        13.5574
    ],
    "group_id": 1343.062198
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Update a group rule.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/ut/group-rule/00903" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "f",
    "description": "Sint magnam enim amet libero sint."
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/ut/group-rule/00903',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'f',
            'description' => 'Sint magnam enim amet libero sint.',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/group-rule/00903"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "f",
    "description": "Sint magnam enim amet libero sint."
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/group-rule/{id}

PATCH api/{ver}/group-rule/{id}

URL Parameters

ver string

id string

The ID of the group rule.

Body Parameters

title string

Must be between 1 and 255 characters.

description string optional

Must be between 1 and 500 characters.

Remove a rule.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/velit/group-rule/93549297" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/velit/group-rule/93549297',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/velit/group-rule/93549297"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/group-to-post

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/debitis/group-to-post" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/debitis/group-to-post',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/debitis/group-to-post"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/group-unblock

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/in/group-unblock" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 22546.28813,
    "user_id": 326943,
    "delete_activities": 1044989.9644
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/in/group-unblock',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 22546.28813,
            'user_id' => 326943.0,
            'delete_activities' => 1044989.9644,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/in/group-unblock"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 22546.28813,
    "user_id": 326943,
    "delete_activities": 1044989.9644
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/group/about-setting/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/animi/group/about-setting/40" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/animi/group/about-setting/40',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/animi/group/about-setting/40"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/group/approve/{id}

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/suscipit/group/approve/5" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/suscipit/group/approve/5',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/suscipit/group/approve/5"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/group/avatar/{id}

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/exercitationem/group/avatar/357" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "image": "aut"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/exercitationem/group/avatar/357',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'image' => 'aut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/exercitationem/group/avatar/357"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "image": "aut"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Browse category.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/mollitia/group/category" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 0.688854,
    "page": 31,
    "q": "placeat",
    "level": 2.947207,
    "limit": 190601720.15413913
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/mollitia/group/category',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 0.688854,
            'page' => 31,
            'q' => 'placeat',
            'level' => 2.947207,
            'limit' => 190601720.15413913,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/mollitia/group/category"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 0.688854,
    "page": 31,
    "q": "placeat",
    "level": 2.947207,
    "limit": 190601720.15413913
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/group/category

URL Parameters

ver string

Body Parameters

id number optional

page number optional

Must be at least 1.

q string optional

level number optional

limit number optional

PUT api/{ver}/group/confirm-answer-question

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/praesentium/group/confirm-answer-question" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 9,
    "is_answer_membership_question": false
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/praesentium/group/confirm-answer-question',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 9,
            'is_answer_membership_question' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/praesentium/group/confirm-answer-question"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 9,
    "is_answer_membership_question": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/group/confirm-rule

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/unde/group/confirm-rule" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 18,
    "is_rule_confirmation": false
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/unde/group/confirm-rule',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 18,
            'is_rule_confirmation' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/unde/group/confirm-rule"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 18,
    "is_rule_confirmation": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/group/cover/{id}

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/exercitationem/group/cover/672179" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "temp_file": 6389.07138556,
    "position": "occaecati"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/exercitationem/group/cover/672179',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'temp_file' => 6389.07138556,
            'position' => 'occaecati',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/exercitationem/group/cover/672179"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "temp_file": 6389.07138556,
    "position": "occaecati"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/group/cover/{id}

URL Parameters

ver string

id string

The ID of the cover.

Body Parameters

image string optional

temp_file number optional

position string optional

DELETE api/{ver}/group/cover/{id}

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/rerum/group/cover/173479" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/rerum/group/cover/173479',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/rerum/group/cover/173479"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/group/feature/{id}

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/qui/group/feature/415489" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "1"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/qui/group/feature/415489',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/group/feature/415489"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "1"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/group/info-setting/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aut/group/info-setting/59" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aut/group/info-setting/59',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/group/info-setting/59"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/praesentium/group/invite-code" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 7.761084,
    "refresh": 340589257
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/praesentium/group/invite-code',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 7.761084,
            'refresh' => 340589257.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/praesentium/group/invite-code"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 7.761084,
    "refresh": 340589257
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/group/invite-code/accept/{code}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/autem/group/invite-code/accept/dolor"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/autem/group/invite-code/accept/dolor');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/autem/group/invite-code/accept/dolor"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/group/invite-code/verify/{code}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ut/group/invite-code/verify/animi"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/ut/group/invite-code/verify/animi');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/group/invite-code/verify/animi"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/deleniti/group/mention" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "autem",
    "page": 21,
    "limit": 27.97230509
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/deleniti/group/mention',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'autem',
            'page' => 21,
            'limit' => 27.97230509,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/deleniti/group/mention"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "autem",
    "page": 21,
    "limit": 27.97230509
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/group/moderation-right/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/fugit/group/moderation-right/51" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/fugit/group/moderation-right/51',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/fugit/group/moderation-right/51"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/group/moderation-right/{id}

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/et/group/moderation-right/377" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/et/group/moderation-right/377',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/group/moderation-right/377"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/group/pending-mode/{id}

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/ut/group/pending-mode/9589" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "pending_mode": 41.4621895
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/ut/group/pending-mode/9589',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'pending_mode' => 41.4621895,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/group/pending-mode/9589"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "pending_mode": 41.4621895
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/group/privacy/change-request/{id}

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/aut/group/privacy/change-request/22428" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/aut/group/privacy/change-request/22428',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/group/privacy/change-request/22428"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/group/privacy/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/qui/group/privacy/57" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/qui/group/privacy/57',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/group/privacy/57"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/group/privacy/{id}

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/beatae/group/privacy/78" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/beatae/group/privacy/78',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/beatae/group/privacy/78"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dolores/group/share-suggestion" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "qui",
    "view": "impedit",
    "sort": "ut",
    "sort_type": "consectetur",
    "when": "voluptate",
    "type_id": 215995.17,
    "category_id": 12.8,
    "owner_id": 16,
    "user_id": 6849.53,
    "is_featured": 4059.891,
    "page": 82,
    "limit": 3358.86
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/dolores/group/share-suggestion',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'qui',
            'view' => 'impedit',
            'sort' => 'ut',
            'sort_type' => 'consectetur',
            'when' => 'voluptate',
            'type_id' => 215995.17,
            'category_id' => 12.8,
            'owner_id' => 16,
            'user_id' => 6849.53,
            'is_featured' => 4059.891,
            'page' => 82,
            'limit' => 3358.86,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolores/group/share-suggestion"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "qui",
    "view": "impedit",
    "sort": "ut",
    "sort_type": "consectetur",
    "when": "voluptate",
    "type_id": 215995.17,
    "category_id": 12.8,
    "owner_id": 16,
    "user_id": 6849.53,
    "is_featured": 4059.891,
    "page": 82,
    "limit": 3358.86
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/group/similar

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptas/group/similar" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "group_id": 6016.20084563,
    "category_id": 45.287,
    "sort": "eaque",
    "when": "ea",
    "limit": 16129325.97
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptas/group/similar',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 6016.20084563,
            'category_id' => 45.287,
            'sort' => 'eaque',
            'when' => 'ea',
            'limit' => 16129325.97,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/group/similar"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "group_id": 6016.20084563,
    "category_id": 45.287,
    "sort": "eaque",
    "when": "ea",
    "limit": 16129325.97
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/group/similar

URL Parameters

ver string

Body Parameters

group_id number optional

category_id number optional

sort string optional

when string optional

limit number optional

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/ducimus/group/sponsor-in-feed/98878805" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": 2.35
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/ducimus/group/sponsor-in-feed/98878805',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 2.35,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ducimus/group/sponsor-in-feed/98878805"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": 2.35
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/ut/group/sponsor/94" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "sunt"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/ut/group/sponsor/94',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'sunt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/group/sponsor/94"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "sunt"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display the specified resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sapiente/group/460" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "invite_code": "architecto"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sapiente/group/460',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'invite_code' => 'architecto',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sapiente/group/460"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "invite_code": "architecto"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Update the specified resource in storage.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/doloremque/group/0" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "name": "praesentium",
    "category_id": 259562559,
    "reg_method": 9659.31,
    "vanity_url": "http:\/\/ryan.net\/deleniti-dolor-vel-unde-nulla",
    "landing_page": "maiores",
    "text_description": "quasi",
    "phone": "ipsum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/doloremque/group/0',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'praesentium',
            'category_id' => 259562559.0,
            'reg_method' => 9659.31,
            'vanity_url' => 'http://ryan.net/deleniti-dolor-vel-unde-nulla',
            'landing_page' => 'maiores',
            'text_description' => 'quasi',
            'phone' => 'ipsum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/doloremque/group/0"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "praesentium",
    "category_id": 259562559,
    "reg_method": 9659.31,
    "vanity_url": "http:\/\/ryan.net\/deleniti-dolor-vel-unde-nulla",
    "landing_page": "maiores",
    "text_description": "quasi",
    "phone": "ipsum"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/group/{id}

PATCH api/{ver}/group/{id}

URL Parameters

ver string

id string

The ID of the group.

Body Parameters

name string optional

This field is required when exists is name.

category_id number optional

reg_method number optional

vanity_url string optional

Must not be greater than 100 characters.

landing_page string

location object optional

text_description string optional

phone string optional

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/sed/group/201" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/sed/group/201',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sed/group/201"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/search-group-member

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quia/search-group-member" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "saepe",
    "group_id": 38640,
    "view": "repudiandae",
    "limit": 6.1
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quia/search-group-member',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'saepe',
            'group_id' => 38640.0,
            'view' => 'repudiandae',
            'limit' => 6.1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quia/search-group-member"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "saepe",
    "group_id": 38640,
    "view": "repudiandae",
    "limit": 6.1
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Hashtags

App name: Hashtags Version: 5.0.14 Author: phpFox Updated at: Aug 02, 2024

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aut/hashtag" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 42,
    "limit": 177359.96230382
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aut/hashtag',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 42,
            'limit' => 177359.96230382,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/hashtag"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 42,
    "limit": 177359.96230382
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dolore/hashtag/suggestion" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "facere",
    "limit": 96123.203
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/dolore/hashtag/suggestion',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'facere',
            'limit' => 96123.203,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolore/hashtag/suggestion"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "facere",
    "limit": 96123.203
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Invitation

App name: Invitation Version: 5.0.12 Author: phpFox Updated at: Aug 02, 2024

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/velit/invite" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "autem",
    "status": "rerum",
    "user_id": 1437.6,
    "view": "alias",
    "page": 16,
    "start_date": "nobis",
    "end_date": "2038-04-29",
    "limit": 4461105
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/velit/invite',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'autem',
            'status' => 'rerum',
            'user_id' => 1437.6,
            'view' => 'alias',
            'page' => 16,
            'start_date' => 'nobis',
            'end_date' => '2038-04-29',
            'limit' => 4461105.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/velit/invite"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "autem",
    "status": "rerum",
    "user_id": 1437.6,
    "view": "alias",
    "page": 16,
    "start_date": "nobis",
    "end_date": "2038-04-29",
    "limit": 4461105
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/invite

URL Parameters

ver string

Body Parameters

q string optional

status string optional

user_id number optional

view string optional

page number optional

Must be at least 1.

start_date string optional

end_date string optional

Must be a date after start_date.

limit number optional

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/explicabo/invite" \
    --header "Content-Type: application/json" \
    --data "{
    "recipients": [
        "ipsum"
    ],
    "message": "aut"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/explicabo/invite',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'recipients' => [
                'ipsum',
            ],
            'message' => 'aut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/explicabo/invite"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "recipients": [
        "ipsum"
    ],
    "message": "aut"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Store item

Example request:

curl --request POST \
    "http://localhost/api/v1/api/aut/invite-code"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/aut/invite-code');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/invite-code"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/invite/batch-delete

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/voluptas/invite/batch-delete" \
    --header "Content-Type: application/json" \
    --data "{
    "ids": [
        1.58
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/voluptas/invite/batch-delete',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'ids' => [
                1.58,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/invite/batch-delete"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "ids": [
        1.58
    ]
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/invite/batch-resend

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/qui/invite/batch-resend" \
    --header "Content-Type: application/json" \
    --data "{
    "ids": [
        6.38270262
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/qui/invite/batch-resend',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'ids' => [
                6.38270262,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/invite/batch-resend"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "ids": [
        6.38270262
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/invite/resend/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/nobis/invite/resend/9"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/nobis/invite/resend/9');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nobis/invite/resend/9"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

Delete item.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/iure/invite/7"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/iure/invite/7');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/iure/invite/7"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

Live Video

App name: Live Video Version: 5.0.16 Author: phpFox Updated at: Aug 02, 2024

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/necessitatibus/live-video" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "aliquam",
    "view": "my_pending",
    "sort": "latest",
    "sort_type": "asc",
    "when": "all",
    "owner_id": 17,
    "user_id": 20,
    "page": 87,
    "limit": 10,
    "duration": "shorter",
    "streaming": 634375175,
    "is_featured": 824580.99915794
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/necessitatibus/live-video',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'aliquam',
            'view' => 'my_pending',
            'sort' => 'latest',
            'sort_type' => 'asc',
            'when' => 'all',
            'owner_id' => 17,
            'user_id' => 20,
            'page' => 87,
            'limit' => 10,
            'duration' => 'shorter',
            'streaming' => 634375175.0,
            'is_featured' => 824580.99915794,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/necessitatibus/live-video"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "aliquam",
    "view": "my_pending",
    "sort": "latest",
    "sort_type": "asc",
    "when": "all",
    "owner_id": 17,
    "user_id": 20,
    "page": 87,
    "limit": 10,
    "duration": "shorter",
    "streaming": 634375175,
    "is_featured": 824580.99915794
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/live-video

URL Parameters

ver string

Body Parameters

q string optional

view string optional

Must be one of all, my, friend, pending, feature, sponsor, search, my_pending, all_streaming, or my_streaming.

sort string optional

Must be one of recent, most_discussed, most_viewed, most_liked, or latest.

sort_type string optional

Must be one of desc or asc.

when string optional

Must be one of all, this_month, this_week, or today.

owner_id integer optional

user_id integer optional

page integer optional

Must be at least 1.

limit integer optional

duration string optional

Must be one of longer or shorter.

streaming number optional

is_featured number optional

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/necessitatibus/live-video" \
    --header "Content-Type: application/json" \
    --data "{
    "stream_key": "alias",
    "owner_id": 105761.36,
    "privacy": "neque",
    "is_landscape": true,
    "file": {
        "temp_file": 156.2
    }
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/necessitatibus/live-video',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'stream_key' => 'alias',
            'owner_id' => 105761.36,
            'privacy' => 'neque',
            'is_landscape' => true,
            'file' => [
                'temp_file' => 156.2,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/necessitatibus/live-video"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "stream_key": "alias",
    "owner_id": 105761.36,
    "privacy": "neque",
    "is_landscape": true,
    "file": {
        "temp_file": 156.2
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/live-video

URL Parameters

ver string

Body Parameters

id string optional

stream_key string

playback_ids object optional

owner_id number optional

privacy string

text string optional

is_landscape boolean optional

title string optional

file object optional

file.temp_file number optional

This field is required when file is present.

location object optional

tagged_friends object optional

post_to string optional

page_id string optional

group_id string optional

to_story string optional

Approve live video.

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/officia/live-video/approve/8"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/officia/live-video/approve/8');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/officia/live-video/approve/8"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/live-video/callback/{provider}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/cumque/live-video/callback/sunt"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/cumque/live-video/callback/sunt');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/cumque/live-video/callback/sunt"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/live-video/end-live/{id}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/suscipit/live-video/end-live/73"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/suscipit/live-video/end-live/73');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/suscipit/live-video/end-live/73"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

Feature live video.

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/enim/live-video/feature/4" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "1"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/enim/live-video/feature/4',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/enim/live-video/feature/4"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "1"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/live-video/go-live

Example request:

curl --request POST \
    "http://localhost/api/v1/api/laboriosam/live-video/go-live" \
    --header "Content-Type: application/json" \
    --data "{
    "stream_key": "culpa",
    "owner_id": 700542,
    "privacy": "non",
    "is_landscape": true,
    "file": {
        "temp_file": 1313832.3769908
    }
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/laboriosam/live-video/go-live',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'stream_key' => 'culpa',
            'owner_id' => 700542.0,
            'privacy' => 'non',
            'is_landscape' => true,
            'file' => [
                'temp_file' => 1313832.3769908,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/laboriosam/live-video/go-live"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "stream_key": "culpa",
    "owner_id": 700542,
    "privacy": "non",
    "is_landscape": true,
    "file": {
        "temp_file": 1313832.3769908
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/live-video/go-live

URL Parameters

ver string

Body Parameters

id string optional

stream_key string

playback_ids object optional

owner_id number optional

privacy string

text string optional

is_landscape boolean optional

title string optional

file object optional

file.temp_file number optional

This field is required when file is present.

location object optional

tagged_friends object optional

post_to string optional

page_id string optional

group_id string optional

to_story string optional

PUT api/{ver}/live-video/off-notification/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/dicta/live-video/off-notification/1"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/dicta/live-video/off-notification/1');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dicta/live-video/off-notification/1"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/live-video/on-notification/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/quod/live-video/on-notification/91883"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/quod/live-video/on-notification/91883');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quod/live-video/on-notification/91883"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/live-video/ping-streaming/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/porro/live-video/ping-streaming/0966"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/porro/live-video/ping-streaming/0966');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/porro/live-video/ping-streaming/0966"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/live-video/ping-viewer/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/enim/live-video/ping-viewer/801695101"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/enim/live-video/ping-viewer/801695101');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/enim/live-video/ping-viewer/801695101"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/live-video/remove-viewer/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/alias/live-video/remove-viewer/4"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/alias/live-video/remove-viewer/4');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/alias/live-video/remove-viewer/4"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/et/live-video/sponsor-in-feed/2908379" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": 12.9
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/et/live-video/sponsor-in-feed/2908379',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 12.9,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/live-video/sponsor-in-feed/2908379"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": 12.9
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/aut/live-video/sponsor/92" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "exercitationem"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/aut/live-video/sponsor/92',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'exercitationem',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/live-video/sponsor/92"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "exercitationem"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/live-video/update-viewer/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/alias/live-video/update-viewer/821"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/alias/live-video/update-viewer/821');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/alias/live-video/update-viewer/821"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

View item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/eaque/live-video/89832"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/eaque/live-video/89832');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eaque/live-video/89832"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Update item.

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/odio/live-video/0" \
    --header "Content-Type: application/json" \
    --data "{
    "file": {
        "temp_file": 9355,
        "status": "officiis"
    }
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/odio/live-video/0',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'file' => [
                'temp_file' => 9355.0,
                'status' => 'officiis',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/odio/live-video/0"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "file": {
        "temp_file": 9355,
        "status": "officiis"
    }
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/live-video/{id}

PATCH api/{ver}/live-video/{id}

URL Parameters

ver string

id string

The ID of the live video.

Body Parameters

playback_ids object optional

status string optional

file object optional

file.temp_file number optional

This field is required when file.status is update.

file.status string optional

This field is required when file is present.

duration string optional

text string optional

title string optional

privacy string optional

location object optional

tagged_friends object optional

Delete item.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/omnis/live-video/74801"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/omnis/live-video/74801');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/omnis/live-video/74801"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

Marketplace

App name: Marketplace Version: 5.0.25 Author: phpFox Updated at: Aug 02, 2024

Browse listing.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptatem/marketplace" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "nobis",
    "view": "ipsa",
    "sort": "neque",
    "sort_type": "aliquid",
    "when": "eum",
    "category_id": 243405.322585215,
    "owner_id": 19,
    "user_id": 0.113881495,
    "page": 13,
    "limit": 234.908773,
    "country_iso": "quibusdam",
    "bounds_west": 1315907.46492,
    "bounds_east": 83.1754,
    "bounds_south": 19.5,
    "bounds_north": 1945337,
    "price_from": 85,
    "price_to": 43
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptatem/marketplace',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'nobis',
            'view' => 'ipsa',
            'sort' => 'neque',
            'sort_type' => 'aliquid',
            'when' => 'eum',
            'category_id' => 243405.322585215,
            'owner_id' => 19,
            'user_id' => 0.113881495,
            'page' => 13,
            'limit' => 234.908773,
            'country_iso' => 'quibusdam',
            'bounds_west' => 1315907.46492,
            'bounds_east' => 83.1754,
            'bounds_south' => 19.5,
            'bounds_north' => 1945337.0,
            'price_from' => 85,
            'price_to' => 43,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatem/marketplace"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "nobis",
    "view": "ipsa",
    "sort": "neque",
    "sort_type": "aliquid",
    "when": "eum",
    "category_id": 243405.322585215,
    "owner_id": 19,
    "user_id": 0.113881495,
    "page": 13,
    "limit": 234.908773,
    "country_iso": "quibusdam",
    "bounds_west": 1315907.46492,
    "bounds_east": 83.1754,
    "bounds_south": 19.5,
    "bounds_north": 1945337,
    "price_from": 85,
    "price_to": 43
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/marketplace

URL Parameters

ver string

Body Parameters

q string optional

view string optional

sort string optional

sort_type string optional

when string optional

category_id number optional

owner_id integer optional

user_id number optional

page number optional

Must be at least 1.

limit number optional

country_iso string optional

bounds_west number optional

bounds_east number optional

bounds_south number optional

bounds_north number optional

price_from number optional

Must be at least 0.

price_to number optional

Must be at least 0.

is_featured string optional

Browe category.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/delectus/marketplace-category" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "quidem",
    "id": 0,
    "level": 0.04,
    "page": 51,
    "limit": 39.333
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/delectus/marketplace-category',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'quidem',
            'id' => 0.0,
            'level' => 0.04,
            'page' => 51,
            'limit' => 39.333,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/delectus/marketplace-category"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "quidem",
    "id": 0,
    "level": 0.04,
    "page": 51,
    "limit": 39.333
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/marketplace-category

URL Parameters

ver string

Body Parameters

q string optional

id number optional

level number optional

page number optional

Must be at least 1.

limit number optional

GET api/{ver}/marketplace-invite

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptatem/marketplace-invite" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptatem/marketplace-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatem/marketplace-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/marketplace-invite

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/qui/marketplace-invite" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "listing_id": 27813.56664,
    "user_ids": [
        9026780.695394736
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/qui/marketplace-invite',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'listing_id' => 27813.56664,
            'user_ids' => [
                9026780.695394736,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/marketplace-invite"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "listing_id": 27813.56664,
    "user_ids": [
        9026780.695394736
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/marketplace-invite/invited-people

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ullam/marketplace-invite/invited-people" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "listing_id": 29139.48,
    "limit": 514750413.6,
    "page": 12
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ullam/marketplace-invite/invited-people',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'listing_id' => 29139.48,
            'limit' => 514750413.6,
            'page' => 12,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ullam/marketplace-invite/invited-people"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "listing_id": 29139.48,
    "limit": 514750413.6,
    "page": 12
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/marketplace-invite/invited-people

URL Parameters

ver string

Body Parameters

listing_id number

limit number optional

page number optional

Must be at least 1.

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quibusdam/marketplace-invoice" \
    --header "Content-Type: application/json" \
    --data "{
    "status": "laudantium",
    "listing_id": 47319.42758,
    "from": "2024-08-02T08:10:41",
    "to": "2120-07-08",
    "page": 46,
    "limit": 19
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quibusdam/marketplace-invoice',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'status' => 'laudantium',
            'listing_id' => 47319.42758,
            'from' => '2024-08-02T08:10:41',
            'to' => '2120-07-08',
            'page' => 46,
            'limit' => 19,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quibusdam/marketplace-invoice"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "status": "laudantium",
    "listing_id": 47319.42758,
    "from": "2024-08-02T08:10:41",
    "to": "2120-07-08",
    "page": 46,
    "limit": 19
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/marketplace-invoice

URL Parameters

ver string

Body Parameters

view string optional

status string optional

listing_id number optional

from string optional

Must be a valid date.

to string optional

Must be a valid date. Must be a date after or equal to from.

page number optional

Must be at least 1.

limit number optional

Must be at least 1.

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/tempora/marketplace-invoice" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 203.244022,
    "payment_gateway": 179456.79137
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/tempora/marketplace-invoice',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 203.244022,
            'payment_gateway' => 179456.79137,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/tempora/marketplace-invoice"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 203.244022,
    "payment_gateway": 179456.79137
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/marketplace-invoice/change

Example request:

curl --request POST \
    "http://localhost/api/v1/api/esse/marketplace-invoice/change" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 259702
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/esse/marketplace-invoice/change',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 259702.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/esse/marketplace-invoice/change"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 259702
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/marketplace-invoice/repayment/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/totam/marketplace-invoice/repayment/86314307" \
    --header "Content-Type: application/json" \
    --data "{
    "payment_gateway": 7464958.629573871,
    "payment_gateway_balance_currency": "qui"
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/totam/marketplace-invoice/repayment/86314307',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'payment_gateway' => 7464958.629573871,
            'payment_gateway_balance_currency' => 'qui',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/totam/marketplace-invoice/repayment/86314307"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "payment_gateway": 7464958.629573871,
    "payment_gateway_balance_currency": "qui"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quaerat/marketplace-invoice/41"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/quaerat/marketplace-invoice/41');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quaerat/marketplace-invoice/41"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Update item.

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/magnam/marketplace-invoice/641176"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/magnam/marketplace-invoice/641176');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/magnam/marketplace-invoice/641176"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

Delete item.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/expedita/marketplace-invoice/7"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/expedita/marketplace-invoice/7');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/expedita/marketplace-invoice/7"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/marketplace-photo/form/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/rerum/marketplace-photo/form/0899" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/rerum/marketplace-photo/form/0899',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/rerum/marketplace-photo/form/0899"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/marketplace-photo/{id}

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/aut/marketplace-photo/795508" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "files": "aut"
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/aut/marketplace-photo/795508',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'files' => 'aut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/marketplace-photo/795508"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "files": "aut"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Approve listing.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/culpa/marketplace/approve/4" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/culpa/marketplace/approve/4',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/culpa/marketplace/approve/4"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Feature listing.

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/non/marketplace/feature/278" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "1"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/non/marketplace/feature/278',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/non/marketplace/feature/278"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "1"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Reopen listing.

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/velit/marketplace/reopen/80" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/velit/marketplace/reopen/80',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/velit/marketplace/reopen/80"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/marketplace/search-suggestion

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aut/marketplace/search-suggestion" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "listing_id": 37.58176,
    "q": "culpa"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aut/marketplace/search-suggestion',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'listing_id' => 37.58176,
            'q' => 'culpa',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/marketplace/search-suggestion"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "listing_id": 37.58176,
    "q": "culpa"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/eveniet/marketplace/sponsor-in-feed/3640" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": 46364.92944793
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/eveniet/marketplace/sponsor-in-feed/3640',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 46364.92944793,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eveniet/marketplace/sponsor-in-feed/3640"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": 46364.92944793
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/sit/marketplace/sponsor/4332" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "vel"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/sit/marketplace/sponsor/4332',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'vel',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sit/marketplace/sponsor/4332"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "vel"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View listing.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/nobis/marketplace/880" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/nobis/marketplace/880',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nobis/marketplace/880"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Remove listing.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/ut/marketplace/3" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/ut/marketplace/3',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/marketplace/3"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

App name: Menu Version: 5.0.13 Author: phpFox Updated at: Aug 02, 2024

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ullam/menu/unde"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/ullam/menu/unde');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ullam/menu/unde"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Multi-Factor Authentication

App name: Multi-Factor Authentication Version: 5.0.15 Author: phpFox Updated at: Aug 02, 2024

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/amet/mfa/service"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/amet/mfa/service');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/amet/mfa/service"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Auth user.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/sunt/mfa/user/auth" \
    --header "Content-Type: application/json" \
    --data "{
    "service": "sint",
    "password": "*ul-Qr'.=$PC@]0i$ce",
    "verification_code": "494488"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/sunt/mfa/user/auth',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'service' => 'sint',
            'password' => '*ul-Qr\'.=$PC@]0i$ce',
            'verification_code' => '494488',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sunt/mfa/user/auth"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "service": "sint",
    "password": "*ul-Qr'.=$PC@]0i$ce",
    "verification_code": "494488"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Setup service form.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptas/mfa/user/auth/form" \
    --header "Content-Type: application/json" \
    --data "{
    "mfa_token": "earum",
    "service": "porro"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptas/mfa/user/auth/form',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'mfa_token' => 'earum',
            'service' => 'porro',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/mfa/user/auth/form"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "mfa_token": "earum",
    "service": "porro"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Setup service form.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/numquam/mfa/user/auth/form" \
    --header "Content-Type: application/json" \
    --data "{
    "mfa_token": "ipsa",
    "service": "laboriosam"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/numquam/mfa/user/auth/form',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'mfa_token' => 'ipsa',
            'service' => 'laboriosam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/numquam/mfa/user/auth/form"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "mfa_token": "ipsa",
    "service": "laboriosam"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/mfa/user/auth/resend

Example request:

curl --request POST \
    "http://localhost/api/v1/api/veritatis/mfa/user/auth/resend" \
    --header "Content-Type: application/json" \
    --data "{
    "service": "placeat",
    "action": "veniam",
    "password": "%~SQ(o"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/veritatis/mfa/user/auth/resend',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'service' => 'placeat',
            'action' => 'veniam',
            'password' => '%~SQ(o',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/veritatis/mfa/user/auth/resend"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "service": "placeat",
    "action": "veniam",
    "password": "%~SQ(o"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Activate service.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/laboriosam/mfa/user/service/activate" \
    --header "Content-Type: application/json" \
    --data "{
    "service": "fugiat",
    "verification_code": "683997"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/laboriosam/mfa/user/service/activate',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'service' => 'fugiat',
            'verification_code' => '683997',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/laboriosam/mfa/user/service/activate"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "service": "fugiat",
    "verification_code": "683997"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Setup service form.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/omnis/mfa/user/service/setup" \
    --header "Content-Type: application/json" \
    --data "{
    "service": "nisi",
    "resolution": "et"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/omnis/mfa/user/service/setup',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'service' => 'nisi',
            'resolution' => 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/omnis/mfa/user/service/setup"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "service": "nisi",
    "resolution": "et"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/mfa/user/service/setup/resend

Example request:

curl --request POST \
    "http://localhost/api/v1/api/temporibus/mfa/user/service/setup/resend" \
    --header "Content-Type: application/json" \
    --data "{
    "service": "dolores",
    "action": "dolorem"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/temporibus/mfa/user/service/setup/resend',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'service' => 'dolores',
            'action' => 'dolorem',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/temporibus/mfa/user/service/setup/resend"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "service": "dolores",
    "action": "dolorem"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Music

App name: Music Version: 5.0.14 Author: phpFox Updated at: Aug 02, 2024

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptatum/music-genre" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 87920.2203716,
    "page": 28,
    "q": "fugit",
    "level": 52.68993,
    "limit": 37196676.77
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptatum/music-genre',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 87920.2203716,
            'page' => 28,
            'q' => 'fugit',
            'level' => 52.68993,
            'limit' => 37196676.77,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatum/music-genre"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 87920.2203716,
    "page": 28,
    "q": "fugit",
    "level": 52.68993,
    "limit": 37196676.77
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/music-genre

URL Parameters

ver string

Body Parameters

id number optional

page number optional

Must be at least 1.

q string optional

level number optional

limit number optional

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/unde/music/album" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "voluptas",
    "view": "ut",
    "sort": "sit",
    "sort_type": "velit",
    "when": "consectetur",
    "owner_id": 3,
    "user_id": 63.9261,
    "page": 75,
    "limit": 634223331.4223439,
    "genre_id": 43153.09,
    "category_id": 1.14189,
    "is_featured": 5.283
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/unde/music/album',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'voluptas',
            'view' => 'ut',
            'sort' => 'sit',
            'sort_type' => 'velit',
            'when' => 'consectetur',
            'owner_id' => 3,
            'user_id' => 63.9261,
            'page' => 75,
            'limit' => 634223331.4223439,
            'genre_id' => 43153.09,
            'category_id' => 1.14189,
            'is_featured' => 5.283,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/unde/music/album"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "voluptas",
    "view": "ut",
    "sort": "sit",
    "sort_type": "velit",
    "when": "consectetur",
    "owner_id": 3,
    "user_id": 63.9261,
    "page": 75,
    "limit": 634223331.4223439,
    "genre_id": 43153.09,
    "category_id": 1.14189,
    "is_featured": 5.283
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/music/album

URL Parameters

ver string

Body Parameters

q string optional

view string optional

sort string optional

sort_type string optional

when string optional

owner_id integer optional

user_id number optional

page number optional

Must be at least 1.

limit number optional

genre_id number optional

category_id number optional

is_featured number optional

PATCH api/{ver}/music/album/feature/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/vitae/music/album/feature/4" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "1"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/vitae/music/album/feature/4',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/vitae/music/album/feature/4"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "1"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/natus/music/album/items/6" \
    --header "Content-Type: application/json" \
    --data "{
    "sort": "suscipit",
    "sort_type": "modi",
    "page": 66,
    "limit": 29837178.3443
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/natus/music/album/items/6',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sort' => 'suscipit',
            'sort_type' => 'modi',
            'page' => 66,
            'limit' => 29837178.3443,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/natus/music/album/items/6"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sort": "suscipit",
    "sort_type": "modi",
    "page": 66,
    "limit": 29837178.3443
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/music/album/items/{id}

URL Parameters

ver string

id string

The ID of the item.

Body Parameters

sort string optional

sort_type string optional

page number optional

Must be at least 1.

limit number optional

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/modi/music/album/sponsor-in-feed/1214" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": 2.747954
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/modi/music/album/sponsor-in-feed/1214',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 2.747954,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/modi/music/album/sponsor-in-feed/1214"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": 2.747954
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/molestiae/music/album/sponsor/13" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "accusamus"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/molestiae/music/album/sponsor/13',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'accusamus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/molestiae/music/album/sponsor/13"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "accusamus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/music/album/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quasi/music/album/5"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/quasi/music/album/5');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quasi/music/album/5"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Delete a resource.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/pariatur/music/album/2517"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/pariatur/music/album/2517');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/pariatur/music/album/2517"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/molestiae/music/genre" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 3434.14733253,
    "page": 89,
    "q": "aliquam",
    "level": 124.95,
    "limit": 2208998.0922441147
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/molestiae/music/genre',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 3434.14733253,
            'page' => 89,
            'q' => 'aliquam',
            'level' => 124.95,
            'limit' => 2208998.0922441147,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/molestiae/music/genre"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 3434.14733253,
    "page": 89,
    "q": "aliquam",
    "level": 124.95,
    "limit": 2208998.0922441147
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/music/genre

URL Parameters

ver string

Body Parameters

id number optional

page number optional

Must be at least 1.

q string optional

level number optional

limit number optional

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/officiis/music/playlist" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "qui",
    "view": "soluta",
    "sort": "ipsam",
    "sort_type": "eos",
    "when": "id",
    "user_id": 37.9618129,
    "page": 61,
    "limit": 46635577.96465262,
    "genre_id": 12,
    "category_id": 7
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/officiis/music/playlist',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'qui',
            'view' => 'soluta',
            'sort' => 'ipsam',
            'sort_type' => 'eos',
            'when' => 'id',
            'user_id' => 37.9618129,
            'page' => 61,
            'limit' => 46635577.96465262,
            'genre_id' => 12,
            'category_id' => 7,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/officiis/music/playlist"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "qui",
    "view": "soluta",
    "sort": "ipsam",
    "sort_type": "eos",
    "when": "id",
    "user_id": 37.9618129,
    "page": 61,
    "limit": 46635577.96465262,
    "genre_id": 12,
    "category_id": 7
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/music/playlist

URL Parameters

ver string

Body Parameters

q string optional

view string optional

sort string optional

sort_type string optional

when string optional

user_id number optional

page number optional

Must be at least 1.

limit number optional

genre_id integer optional

category_id integer optional

POST api/{ver}/music/playlist

Example request:

curl --request POST \
    "http://localhost/api/v1/api/soluta/music/playlist" \
    --header "Content-Type: application/json" \
    --data "{
    "name": "fugit",
    "description": "Numquam sit eaque deserunt nihil ullam.",
    "thumbnail": {
        "temp_file": 23848.2132
    },
    "owner_id": 41218609.916286,
    "privacy": "molestiae",
    "attachments": [
        "quibusdam"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/soluta/music/playlist',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'fugit',
            'description' => 'Numquam sit eaque deserunt nihil ullam.',
            'thumbnail' => [
                'temp_file' => 23848.2132,
            ],
            'owner_id' => 41218609.916286,
            'privacy' => 'molestiae',
            'attachments' => [
                'quibusdam',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/soluta/music/playlist"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "fugit",
    "description": "Numquam sit eaque deserunt nihil ullam.",
    "thumbnail": {
        "temp_file": 23848.2132
    },
    "owner_id": 41218609.916286,
    "privacy": "molestiae",
    "attachments": [
        "quibusdam"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/music/playlist

URL Parameters

ver string

Body Parameters

name string

description string optional

thumbnail object optional

thumbnail.temp_file number optional

This field is required when thumbnail is present.

owner_id number optional

privacy string

attachments number[] optional

attachments[].id number optional

attachments[].status string optional

POST api/{ver}/music/playlist/add-song

Example request:

curl --request POST \
    "http://localhost/api/v1/api/ex/music/playlist/add-song" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 59687.97782785,
    "playlist_ids": [
        618645.099704305
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/ex/music/playlist/add-song',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 59687.97782785,
            'playlist_ids' => [
                618645.099704305,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ex/music/playlist/add-song"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 59687.97782785,
    "playlist_ids": [
        618645.099704305
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/id/music/playlist/items/5" \
    --header "Content-Type: application/json" \
    --data "{
    "sort": "eveniet",
    "sort_type": "magni",
    "page": 49,
    "limit": 35848.1160315
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/id/music/playlist/items/5',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sort' => 'eveniet',
            'sort_type' => 'magni',
            'page' => 49,
            'limit' => 35848.1160315,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/id/music/playlist/items/5"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sort": "eveniet",
    "sort_type": "magni",
    "page": 49,
    "limit": 35848.1160315
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/music/playlist/items/{id}

URL Parameters

ver string

id string

The ID of the item.

Body Parameters

sort string optional

sort_type string optional

page number optional

Must be at least 1.

limit number optional

GET api/{ver}/music/playlist/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/itaque/music/playlist/9"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/itaque/music/playlist/9');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/itaque/music/playlist/9"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Update a resource.

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/aut/music/playlist/395" \
    --header "Content-Type: application/json" \
    --data "{
    "name": "quia",
    "description": "Assumenda aut quis sunt tenetur ut ipsum.",
    "thumbnail": {
        "temp_file": 25223698.8219,
        "status": "sit"
    },
    "owner_id": 371.01,
    "privacy": "vel",
    "attachments": [
        "iure"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/aut/music/playlist/395',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'quia',
            'description' => 'Assumenda aut quis sunt tenetur ut ipsum.',
            'thumbnail' => [
                'temp_file' => 25223698.8219,
                'status' => 'sit',
            ],
            'owner_id' => 371.01,
            'privacy' => 'vel',
            'attachments' => [
                'iure',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/music/playlist/395"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "quia",
    "description": "Assumenda aut quis sunt tenetur ut ipsum.",
    "thumbnail": {
        "temp_file": 25223698.8219,
        "status": "sit"
    },
    "owner_id": 371.01,
    "privacy": "vel",
    "attachments": [
        "iure"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/music/playlist/{id}

PATCH api/{ver}/music/playlist/{id}

URL Parameters

ver string

id string

The ID of the playlist.

Body Parameters

name string

description string optional

thumbnail object optional

thumbnail.temp_file number optional

This field is required when file.status is update.

thumbnail.status string optional

This field is required when file is present.

owner_id number optional

privacy string

attachments number[] optional

attachments[].id number optional

attachments[].status string optional

Delete a resource.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/consequatur/music/playlist/82"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/consequatur/music/playlist/82');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consequatur/music/playlist/82"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/music/search

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/mollitia/music/search"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/mollitia/music/search');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/mollitia/music/search"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/veniam/music/song" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "aut",
    "view": "blanditiis",
    "sort": "vitae",
    "sort_type": "facere",
    "when": "doloribus",
    "owner_id": 17,
    "user_id": 3080982.522,
    "genre_id": 394978.165,
    "category_id": 8,
    "page": 56,
    "limit": 262.6892333,
    "is_featured": 5574563.67
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/veniam/music/song',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'aut',
            'view' => 'blanditiis',
            'sort' => 'vitae',
            'sort_type' => 'facere',
            'when' => 'doloribus',
            'owner_id' => 17,
            'user_id' => 3080982.522,
            'genre_id' => 394978.165,
            'category_id' => 8,
            'page' => 56,
            'limit' => 262.6892333,
            'is_featured' => 5574563.67,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/veniam/music/song"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "aut",
    "view": "blanditiis",
    "sort": "vitae",
    "sort_type": "facere",
    "when": "doloribus",
    "owner_id": 17,
    "user_id": 3080982.522,
    "genre_id": 394978.165,
    "category_id": 8,
    "page": 56,
    "limit": 262.6892333,
    "is_featured": 5574563.67
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/music/song

URL Parameters

ver string

Body Parameters

q string optional

view string optional

sort string optional

sort_type string optional

when string optional

owner_id integer optional

user_id number optional

genre_id number optional

category_id integer optional

page number optional

Must be at least 1.

limit number optional

is_featured number optional

POST api/{ver}/music/song

Example request:

curl --request POST \
    "http://localhost/api/v1/api/odio/music/song" \
    --header "Content-Type: application/json" \
    --data "{
    "name": "laboriosam",
    "description": "Accusamus quia rerum aliquid minima impedit.",
    "genres": [
        373.8
    ],
    "owner_id": 835568255,
    "privacy": "eaque",
    "attachments": [
        "velit"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/odio/music/song',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'laboriosam',
            'description' => 'Accusamus quia rerum aliquid minima impedit.',
            'genres' => [
                373.8,
            ],
            'owner_id' => 835568255.0,
            'privacy' => 'eaque',
            'attachments' => [
                'velit',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/odio/music/song"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "laboriosam",
    "description": "Accusamus quia rerum aliquid minima impedit.",
    "genres": [
        373.8
    ],
    "owner_id": 835568255,
    "privacy": "eaque",
    "attachments": [
        "velit"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/music/song

URL Parameters

ver string

Body Parameters

name string

description string optional

file string optional

thumbnail string optional

genres number[] optional

This field is required when genres is present.

owner_id number optional

privacy string

attachments number[] optional

attachments[].id number optional

attachments[].status string optional

Approve song.

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/vel/music/song/approve/7"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/vel/music/song/approve/7');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/vel/music/song/approve/7"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

Display the specified resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ad/music/song/download/5"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/ad/music/song/download/5');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ad/music/song/download/5"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/music/song/feature/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/rerum/music/song/feature/9" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "0"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/rerum/music/song/feature/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '0',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/rerum/music/song/feature/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "0"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/nobis/music/song/sponsor-in-feed/89" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": 5329230.51
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/nobis/music/song/sponsor-in-feed/89',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 5329230.51,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nobis/music/song/sponsor-in-feed/89"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": 5329230.51
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/alias/music/song/sponsor/05" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "sequi"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/alias/music/song/sponsor/05',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'sequi',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/alias/music/song/sponsor/05"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "sequi"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/music/song/{id}/remove-from-playlist/{playlist_id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/et/music/song/80/remove-from-playlist/delectus"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/et/music/song/80/remove-from-playlist/delectus');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/music/song/80/remove-from-playlist/delectus"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/music/song/{id}/statistic/total-play

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/nam/music/song/007/statistic/total-play"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/nam/music/song/007/statistic/total-play');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nam/music/song/007/statistic/total-play"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/music/song/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/provident/music/song/6699"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/provident/music/song/6699');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/provident/music/song/6699"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Delete a resource.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/nisi/music/song/0176"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/nisi/music/song/0176');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nisi/music/song/0176"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

Notification

App name: Notification Version: 5.0.16 Author: phpFox Updated at: Aug 02, 2024

Browse current user's notifications.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/est/notification" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 1,
    "limit": 4
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/est/notification',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 1,
            'limit' => 4,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/est/notification"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 1,
    "limit": 4
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/notification/all

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/in/notification/all" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/in/notification/all',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/in/notification/all"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Mark all as read.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/et/notification/markAllAsRead" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/et/notification/markAllAsRead',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/notification/markAllAsRead"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Update item

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/maiores/notification/setting"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/maiores/notification/setting');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/maiores/notification/setting"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/notification/setting/form

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/saepe/notification/setting/form"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/saepe/notification/setting/form');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/saepe/notification/setting/form"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Mark as read.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/excepturi/notification/1" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/excepturi/notification/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/excepturi/notification/1"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Delete notification.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/et/notification/0665" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/et/notification/0665',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/notification/0665"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Page

App name: Page Version: 5.0.22 Author: phpFox Updated at: Aug 02, 2024

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quia/page" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "sed",
    "view": "est",
    "sort": "voluptates",
    "sort_type": "nihil",
    "when": "recusandae",
    "category_id": 26.6,
    "owner_id": 11,
    "user_id": 37686676.507,
    "is_featured": 475,
    "page": 56,
    "limit": 0
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quia/page',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'sed',
            'view' => 'est',
            'sort' => 'voluptates',
            'sort_type' => 'nihil',
            'when' => 'recusandae',
            'category_id' => 26.6,
            'owner_id' => 11,
            'user_id' => 37686676.507,
            'is_featured' => 475.0,
            'page' => 56,
            'limit' => 0.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quia/page"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "sed",
    "view": "est",
    "sort": "voluptates",
    "sort_type": "nihil",
    "when": "recusandae",
    "category_id": 26.6,
    "owner_id": 11,
    "user_id": 37686676.507,
    "is_featured": 475,
    "page": 56,
    "limit": 0
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/page

URL Parameters

ver string

Body Parameters

q string optional

view string optional

sort string optional

sort_type string optional

when string optional

category_id number optional

owner_id integer optional

user_id number optional

is_featured number optional

page number optional

Must be at least 1.

limit number optional

Store a newly created resource in storage.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/aut/page" \
    --header "Content-Type: application/json" \
    --data "{
    "name": "enim",
    "category_id": 3936.82234,
    "text": "voluptas",
    "users": [
        "modi"
    ],
    "external_link": "http:\/\/www.funk.net\/voluptas-sunt-delectus-magni-maxime-sit-et",
    "image": {
        "base64": "cum"
    }
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/aut/page',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'enim',
            'category_id' => 3936.82234,
            'text' => 'voluptas',
            'users' => [
                'modi',
            ],
            'external_link' => 'http://www.funk.net/voluptas-sunt-delectus-magni-maxime-sit-et',
            'image' => [
                'base64' => 'cum',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/page"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "enim",
    "category_id": 3936.82234,
    "text": "voluptas",
    "users": [
        "modi"
    ],
    "external_link": "http:\/\/www.funk.net\/voluptas-sunt-delectus-magni-maxime-sit-et",
    "image": {
        "base64": "cum"
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/page

URL Parameters

ver string

Body Parameters

name string

category_id number optional

text string optional

users number[] optional

users[].id number optional

external_link string optional

Must be a valid URL.

image object optional

image.base64 string optional

Display a listing of the admin resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/cumque/page-admin" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "sint",
    "page_id": 311733.6201739,
    "page": 60,
    "limit": 48279028.53467341,
    "view": "deserunt",
    "not_invite_role": 42058,
    "excluded_user_id": 1318465.75119
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/cumque/page-admin',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'sint',
            'page_id' => 311733.6201739,
            'page' => 60,
            'limit' => 48279028.53467341,
            'view' => 'deserunt',
            'not_invite_role' => 42058.0,
            'excluded_user_id' => 1318465.75119,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/cumque/page-admin"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "sint",
    "page_id": 311733.6201739,
    "page": 60,
    "limit": 48279028.53467341,
    "view": "deserunt",
    "not_invite_role": 42058,
    "excluded_user_id": 1318465.75119
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/page-admin

URL Parameters

ver string

Body Parameters

q string optional

page_id number

page number optional

Must be at least 1.

limit number optional

view string optional

not_invite_role number optional

excluded_user_id number optional

POST api/{ver}/page-admin

Example request:

curl --request POST \
    "http://localhost/api/v1/api/cumque/page-admin" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 653.09,
    "user_ids": [
        36509433.40672271
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/cumque/page-admin',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 653.09,
            'user_ids' => [
                36509433.40672271,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/cumque/page-admin"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 653.09,
    "user_ids": [
        36509433.40672271
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/page-admin

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/voluptas/page-admin" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 31.367,
    "user_id": 8995763.399711,
    "is_delete": 2049.3
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/voluptas/page-admin',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 31.367,
            'user_id' => 8995763.399711,
            'is_delete' => 2049.3,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/page-admin"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 31.367,
    "user_id": 8995763.399711,
    "is_delete": 2049.3
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/reiciendis/page-block" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 24,
    "view": "commodi",
    "q": "repudiandae",
    "page": 7,
    "limit": 559529.95
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/reiciendis/page-block',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 24.0,
            'view' => 'commodi',
            'q' => 'repudiandae',
            'page' => 7,
            'limit' => 559529.95,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/reiciendis/page-block"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 24,
    "view": "commodi",
    "q": "repudiandae",
    "page": 7,
    "limit": 559529.95
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/page-block

URL Parameters

ver string

Body Parameters

page_id number

view string optional

q string optional

page number optional

Must be at least 1.

limit number optional

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/dolores/page-block" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 184509.290481,
    "user_id": 0
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/dolores/page-block',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 184509.290481,
            'user_id' => 0.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolores/page-block"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 184509.290481,
    "user_id": 0
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/cum/page-claim" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "aspernatur",
    "sort": "similique",
    "sort_type": "eligendi",
    "when": "tempora",
    "category_id": 3,
    "owner_id": 4,
    "page": 49,
    "limit": 368599930.61687
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/cum/page-claim',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'aspernatur',
            'sort' => 'similique',
            'sort_type' => 'eligendi',
            'when' => 'tempora',
            'category_id' => 3.0,
            'owner_id' => 4,
            'page' => 49,
            'limit' => 368599930.61687,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/cum/page-claim"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "aspernatur",
    "sort": "similique",
    "sort_type": "eligendi",
    "when": "tempora",
    "category_id": 3,
    "owner_id": 4,
    "page": 49,
    "limit": 368599930.61687
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/page-claim

URL Parameters

ver string

Body Parameters

q string optional

sort string optional

sort_type string optional

when string optional

status string optional

category_id number optional

owner_id integer optional

page number optional

Must be at least 1.

limit number optional

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/repellat/page-claim" \
    --header "Content-Type: application/json" \
    --data "{
    "message": "sed",
    "page_id": 58.33
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/repellat/page-claim',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'message' => 'sed',
            'page_id' => 58.33,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/repellat/page-claim"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "message": "sed",
    "page_id": 58.33
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/page-claim/resubmit/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/at/page-claim/resubmit/8"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/at/page-claim/resubmit/8');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/at/page-claim/resubmit/8"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/page-claim/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptas/page-claim/0576419"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/voluptas/page-claim/0576419');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/page-claim/0576419"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Update item.

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/ducimus/page-claim/797" \
    --header "Content-Type: application/json" \
    --data "{
    "message": "nisi",
    "status": 16
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/ducimus/page-claim/797',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'message' => 'nisi',
            'status' => 16,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ducimus/page-claim/797"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "message": "nisi",
    "status": 16
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/page-claim/{id}

PATCH api/{ver}/page-claim/{id}

URL Parameters

ver string

id string

The ID of the page claim.

Body Parameters

message string optional

status integer optional

Display the specified resource info.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/maxime/page-info/4312"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/maxime/page-info/4312');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/maxime/page-info/4312"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Reorder example rule.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/recusandae/page-integrated/order" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 72791684.2999
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/recusandae/page-integrated/order',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 72791684.2999,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/recusandae/page-integrated/order"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 72791684.2999
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Update item.

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/rerum/page-integrated/4"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/rerum/page-integrated/4');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/rerum/page-integrated/4"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aut/page-invite" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "debitis",
    "page_id": 12.7047,
    "page": 34,
    "limit": 38
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aut/page-invite',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'debitis',
            'page_id' => 12.7047,
            'page' => 34,
            'limit' => 38,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/page-invite"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "debitis",
    "page_id": 12.7047,
    "page": 34,
    "limit": 38
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/page-invite

URL Parameters

ver string

Body Parameters

q string optional

page_id number

page number optional

Must be at least 1.

limit number optional

Must be at least 10.

Store a newly created resource in storage.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/est/page-invite" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 1436739.46947,
    "user_ids": []
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/est/page-invite',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 1436739.46947,
            'user_ids' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/est/page-invite"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 1436739.46947,
    "user_ids": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Used to accept/decline a request to like a page.

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/deleniti/page-invite/1" \
    --header "Content-Type: application/json" \
    --data "{
    "accept": 13994764.8
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/deleniti/page-invite/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'accept' => 13994764.8,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/deleniti/page-invite/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "accept": 13994764.8
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Remove the specified resource from storage.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/quis/page-invite/937476" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": 4
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/quis/page-invite/937476',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 4,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quis/page-invite/937476"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 4
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/recusandae/page-member" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "qui",
    "page_id": 72.923328,
    "page": 83,
    "limit": 1451.3701374,
    "view": "assumenda",
    "not_invite_role": 26767.784844108,
    "excluded_user_id": 4912865.543350026
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/recusandae/page-member',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'qui',
            'page_id' => 72.923328,
            'page' => 83,
            'limit' => 1451.3701374,
            'view' => 'assumenda',
            'not_invite_role' => 26767.784844108,
            'excluded_user_id' => 4912865.543350026,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/recusandae/page-member"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "qui",
    "page_id": 72.923328,
    "page": 83,
    "limit": 1451.3701374,
    "view": "assumenda",
    "not_invite_role": 26767.784844108,
    "excluded_user_id": 4912865.543350026
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/page-member

URL Parameters

ver string

Body Parameters

q string optional

page_id number

page number optional

Must be at least 1.

limit number optional

view string optional

not_invite_role number optional

excluded_user_id number optional

Store a newly created resource in storage.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/beatae/page-member" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 9665601.18
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/beatae/page-member',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 9665601.18,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/beatae/page-member"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 9665601.18
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/page-member/add-page-admin

Example request:

curl --request POST \
    "http://localhost/api/v1/api/quis/page-member/add-page-admin" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 81376.15813,
    "user_ids": [
        46.07848
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/quis/page-member/add-page-admin',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 81376.15813,
            'user_ids' => [
                46.07848,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quis/page-member/add-page-admin"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 81376.15813,
    "user_ids": [
        46.07848
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/page-member/cancel-invite

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/voluptas/page-member/cancel-invite" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 5.47431,
    "user_id": 0.1,
    "invite_type": "dignissimos"
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/voluptas/page-member/cancel-invite',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 5.47431,
            'user_id' => 0.1,
            'invite_type' => 'dignissimos',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/page-member/cancel-invite"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 5.47431,
    "user_id": 0.1,
    "invite_type": "dignissimos"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Reassign group owner.

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/inventore/page-member/reassign-owner" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 334.07691376,
    "user_id": 5127.969243733,
    "users": [
        "consequatur"
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/inventore/page-member/reassign-owner',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 334.07691376,
            'user_id' => 5127.969243733,
            'users' => [
                'consequatur',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/inventore/page-member/reassign-owner"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 334.07691376,
    "user_id": 5127.969243733,
    "users": [
        "consequatur"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/page-member/reassign-owner

URL Parameters

ver string

Body Parameters

page_id number

user_id number optional

This field is required when users is not present.

users number[] optional

users[].id number optional

This field is required when users is present.

Delete group member.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/incidunt/page-member/remove-page-admin" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 218384548.89072564,
    "user_id": 7.299,
    "is_delete": 11259.027
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/incidunt/page-member/remove-page-admin',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 218384548.89072564,
            'user_id' => 7.299,
            'is_delete' => 11259.027,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/incidunt/page-member/remove-page-admin"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 218384548.89072564,
    "user_id": 7.299,
    "is_delete": 11259.027
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Delete group member.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/eaque/page-member/remove-page-member" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 0,
    "user_id": 0.105
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/eaque/page-member/remove-page-member',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 0.0,
            'user_id' => 0.105,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eaque/page-member/remove-page-member"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 0,
    "user_id": 0.105
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Remove the specified resource from storage.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/expedita/page-member/22"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/expedita/page-member/22');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/expedita/page-member/22"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/page-to-post

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/nostrum/page-to-post"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/nostrum/page-to-post');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nostrum/page-to-post"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/page-unblock

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/at/page-unblock" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 7117133.06,
    "user_id": 155.872164709
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/at/page-unblock',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 7117133.06,
            'user_id' => 155.872164709,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/at/page-unblock"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 7117133.06,
    "user_id": 155.872164709
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/page/about-setting/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ut/page/about-setting/01"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/ut/page/about-setting/01');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/page/about-setting/01"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/page/approve/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/quia/page/approve/1"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/quia/page/approve/1');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quia/page/approve/1"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/page/avatar/{id}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/corrupti/page/avatar/3" \
    --header "Content-Type: application/json" \
    --data "{
    "image_crop": "tempora",
    "temp_file": 532942.100331,
    "photo_id": 10.233427
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/corrupti/page/avatar/3',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'image_crop' => 'tempora',
            'temp_file' => 532942.100331,
            'photo_id' => 10.233427,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/corrupti/page/avatar/3"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "image_crop": "tempora",
    "temp_file": 532942.100331,
    "photo_id": 10.233427
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/page/avatar/{id}

URL Parameters

ver string

id string

The ID of the avatar.

Body Parameters

image string optional

image_crop string

temp_file number optional

photo_id number optional

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptatem/page/category" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 40,
    "parent_id": 53329.68293,
    "q": "quos",
    "level": 117.529906991,
    "limit": 356582.65801
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptatem/page/category',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 40,
            'parent_id' => 53329.68293,
            'q' => 'quos',
            'level' => 117.529906991,
            'limit' => 356582.65801,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatem/page/category"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 40,
    "parent_id": 53329.68293,
    "q": "quos",
    "level": 117.529906991,
    "limit": 356582.65801
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/page/category

URL Parameters

ver string

Body Parameters

page number optional

Must be at least 1.

parent_id number optional

q string optional

level number optional

limit number optional

POST api/{ver}/page/cover/{id}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/explicabo/page/cover/42" \
    --header "Content-Type: application/json" \
    --data "{
    "temp_file": 488830359.839717,
    "position": "laboriosam"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/explicabo/page/cover/42',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'temp_file' => 488830359.839717,
            'position' => 'laboriosam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/explicabo/page/cover/42"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "temp_file": 488830359.839717,
    "position": "laboriosam"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/page/cover/{id}

URL Parameters

ver string

id string

The ID of the cover.

Body Parameters

image string optional

temp_file number optional

position string optional

DELETE api/{ver}/page/cover/{id}

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/corporis/page/cover/0310"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/corporis/page/cover/0310');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/corporis/page/cover/0310"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/page/feature/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/dolorem/page/feature/648" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "1"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/dolorem/page/feature/648',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolorem/page/feature/648"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "1"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/page/info-setting/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/omnis/page/info-setting/1"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/omnis/page/info-setting/1');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/omnis/page/info-setting/1"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/qui/page/mention" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "cum",
    "page": 13,
    "limit": 3.012
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/qui/page/mention',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'cum',
            'page' => 13,
            'limit' => 3.012,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/page/mention"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "cum",
    "page": 13,
    "limit": 3.012
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/page/privacy/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dolor/page/privacy/040"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/dolor/page/privacy/040');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolor/page/privacy/040"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/page/privacy/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/est/page/privacy/7"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/est/page/privacy/7');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/est/page/privacy/7"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/corrupti/page/share-suggestion" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "velit",
    "view": "velit",
    "sort": "consequuntur",
    "sort_type": "ad",
    "when": "commodi",
    "category_id": 17064,
    "owner_id": 3,
    "user_id": 918469.551,
    "is_featured": 3420971.94,
    "page": 17,
    "limit": 0.7292479
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/corrupti/page/share-suggestion',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'velit',
            'view' => 'velit',
            'sort' => 'consequuntur',
            'sort_type' => 'ad',
            'when' => 'commodi',
            'category_id' => 17064.0,
            'owner_id' => 3,
            'user_id' => 918469.551,
            'is_featured' => 3420971.94,
            'page' => 17,
            'limit' => 0.7292479,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/corrupti/page/share-suggestion"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "velit",
    "view": "velit",
    "sort": "consequuntur",
    "sort_type": "ad",
    "when": "commodi",
    "category_id": 17064,
    "owner_id": 3,
    "user_id": 918469.551,
    "is_featured": 3420971.94,
    "page": 17,
    "limit": 0.7292479
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aut/page/similar" \
    --header "Content-Type: application/json" \
    --data "{
    "page_id": 93.64847,
    "category_id": 264243.5051,
    "sort": "animi",
    "when": "natus",
    "limit": 647.1248884
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aut/page/similar',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page_id' => 93.64847,
            'category_id' => 264243.5051,
            'sort' => 'animi',
            'when' => 'natus',
            'limit' => 647.1248884,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/page/similar"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page_id": 93.64847,
    "category_id": 264243.5051,
    "sort": "animi",
    "when": "natus",
    "limit": 647.1248884
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/page/similar

URL Parameters

ver string

Body Parameters

page_id number optional

category_id number optional

sort string optional

when string optional

limit number optional

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/minus/page/sponsor/66568" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "unde"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/minus/page/sponsor/66568',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'unde',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/minus/page/sponsor/66568"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "unde"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display the specified resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/doloremque/page/26"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/doloremque/page/26');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/doloremque/page/26"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Remove the specified resource from storage.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/adipisci/page/27"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/adipisci/page/27');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/adipisci/page/27"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/search-page-member

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/tenetur/search-page-member" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "nostrum",
    "page_id": 5.47940104,
    "view": "quidem",
    "limit": 66247667.86102685
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/tenetur/search-page-member',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'nostrum',
            'page_id' => 5.47940104,
            'view' => 'quidem',
            'limit' => 66247667.86102685,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/tenetur/search-page-member"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "nostrum",
    "page_id": 5.47940104,
    "view": "quidem",
    "limit": 66247667.86102685
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PayPal

App name: PayPal Version: 5.0.13 Author: phpFox Updated at: Aug 02, 2024

notify.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/et/paypal/notify"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/et/paypal/notify');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/paypal/notify"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

Payment Gateway

App name: Payment Gateway Version: 5.0.14 Author: phpFox Updated at: Aug 02, 2024

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dolorem/payment-gateway" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 55,
    "limit": 287464.747615
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/dolorem/payment-gateway',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 55,
            'limit' => 287464.747615,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolorem/payment-gateway"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 55,
    "limit": 287464.747615
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/payment-gateway/configuration

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/a/payment-gateway/configuration"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/a/payment-gateway/configuration');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/a/payment-gateway/configuration"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/payment-gateway/configuration-form/{driver}/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dicta/payment-gateway/configuration-form/laborum/94646"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/dicta/payment-gateway/configuration-form/laborum/94646');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dicta/payment-gateway/configuration-form/laborum/94646"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/payment-gateway/configuration-multiple

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/aliquid/payment-gateway/configuration-multiple"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/aliquid/payment-gateway/configuration-multiple');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aliquid/payment-gateway/configuration-multiple"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/payment-gateway/configuration/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/ut/payment-gateway/configuration/17" \
    --header "Content-Type: application/json" \
    --data "{
    "gateway_id": 13
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/ut/payment-gateway/configuration/17',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'gateway_id' => 13.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/payment-gateway/configuration/17"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "gateway_id": 13
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/facere/payment-order"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/facere/payment-order');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/facere/payment-order"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

View item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/officia/payment-order/17"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/officia/payment-order/17');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/officia/payment-order/17"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Update item.

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/praesentium/payment-order/4862" \
    --header "Content-Type: application/json" \
    --data "{
    "gateway_id": 255472.05957
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/praesentium/payment-order/4862',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'gateway_id' => 255472.05957,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/praesentium/payment-order/4862"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "gateway_id": 255472.05957
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Payment Processor

App name: Payment Processor Version: 5.0.5 Author: phpFox Updated at: Aug 02, 2024

POST api/{ver}/payment-processor/callback/{processor}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/blanditiis/payment-processor/callback/voluptatem"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/blanditiis/payment-processor/callback/voluptatem');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/blanditiis/payment-processor/callback/voluptatem"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

Photo

App name: Photo Version: 5.0.21 Author: phpFox Updated at: Aug 02, 2024

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/officiis/photo" \
    --header "Content-Type: application/json" \
    --data "{
    "owner_id": 15,
    "user_id": 0.485754401,
    "category_id": 369609411.69095963,
    "album_id": 96715.8671067,
    "group_id": 0.72,
    "q": "non",
    "tag": "voluptas",
    "feed_id": 95498.716301,
    "view": "non",
    "sort": "id",
    "sort_type": "ullam",
    "when": "exercitationem",
    "page": 51,
    "limit": 97242018.7517379,
    "is_featured": 44.37179
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/officiis/photo',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'owner_id' => 15,
            'user_id' => 0.485754401,
            'category_id' => 369609411.69095963,
            'album_id' => 96715.8671067,
            'group_id' => 0.72,
            'q' => 'non',
            'tag' => 'voluptas',
            'feed_id' => 95498.716301,
            'view' => 'non',
            'sort' => 'id',
            'sort_type' => 'ullam',
            'when' => 'exercitationem',
            'page' => 51,
            'limit' => 97242018.7517379,
            'is_featured' => 44.37179,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/officiis/photo"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "owner_id": 15,
    "user_id": 0.485754401,
    "category_id": 369609411.69095963,
    "album_id": 96715.8671067,
    "group_id": 0.72,
    "q": "non",
    "tag": "voluptas",
    "feed_id": 95498.716301,
    "view": "non",
    "sort": "id",
    "sort_type": "ullam",
    "when": "exercitationem",
    "page": 51,
    "limit": 97242018.7517379,
    "is_featured": 44.37179
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/photo

URL Parameters

ver string

Body Parameters

owner_id integer optional

user_id number optional

category_id number optional

album_id number optional

group_id number optional

q string optional

tag string optional

feed_id number optional

view string optional

sort string optional

sort_type string optional

when string optional

page number optional

Must be at least 1.

limit number optional

is_featured number optional

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/enim/photo-album" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "voluptatum",
    "owner_id": 16,
    "user_id": 353098,
    "view": "laboriosam",
    "sort": "similique",
    "sort_type": "repudiandae",
    "when": "quia",
    "page": 84,
    "limit": 61756380.79350855,
    "is_featured": 3039.1228
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/enim/photo-album',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'voluptatum',
            'owner_id' => 16,
            'user_id' => 353098.0,
            'view' => 'laboriosam',
            'sort' => 'similique',
            'sort_type' => 'repudiandae',
            'when' => 'quia',
            'page' => 84,
            'limit' => 61756380.79350855,
            'is_featured' => 3039.1228,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/enim/photo-album"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "voluptatum",
    "owner_id": 16,
    "user_id": 353098,
    "view": "laboriosam",
    "sort": "similique",
    "sort_type": "repudiandae",
    "when": "quia",
    "page": 84,
    "limit": 61756380.79350855,
    "is_featured": 3039.1228
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/photo-album

URL Parameters

ver string

Body Parameters

q string optional

owner_id integer optional

user_id number optional

view string optional

sort string optional

sort_type string optional

when string optional

page number optional

Must be at least 1.

limit number optional

is_featured number optional

PATCH api/{ver}/photo-album/approve/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/quia/photo-album/approve/114120"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/quia/photo-album/approve/114120');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quia/photo-album/approve/114120"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/photo-album/create

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/porro/photo-album/create"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/porro/photo-album/create');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/porro/photo-album/create"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/photo-album/feature/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/dolorem/photo-album/feature/6" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "1"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/dolorem/photo-album/feature/6',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolorem/photo-album/feature/6"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "1"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sint/photo-album/items/1858" \
    --header "Content-Type: application/json" \
    --data "{
    "sort": "a",
    "sort_type": "assumenda",
    "page": 59,
    "limit": 2.8483158,
    "media_id": 19
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sint/photo-album/items/1858',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sort' => 'a',
            'sort_type' => 'assumenda',
            'page' => 59,
            'limit' => 2.8483158,
            'media_id' => 19,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sint/photo-album/items/1858"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sort": "a",
    "sort_type": "assumenda",
    "page": 59,
    "limit": 2.8483158,
    "media_id": 19
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/photo-album/items/{id}

URL Parameters

ver string

id string

The ID of the item.

Body Parameters

sort string optional

sort_type string optional

page number optional

Must be at least 1.

limit number optional

media_id integer optional

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/officia/photo-album/sponsor/2" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "temporibus"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/officia/photo-album/sponsor/2',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'temporibus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/officia/photo-album/sponsor/2"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "temporibus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display the specified resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/incidunt/photo-album/772"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/incidunt/photo-album/772');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/incidunt/photo-album/772"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Remove the specified resource from storage.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/omnis/photo-album/8"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/omnis/photo-album/8');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/omnis/photo-album/8"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/photo-album/{photo_album}/edit

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/molestiae/photo-album/est/edit"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/molestiae/photo-album/est/edit');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/molestiae/photo-album/est/edit"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/in/photo-category" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 413.854782167,
    "page": 14,
    "q": "alias",
    "level": 2.699197,
    "limit": 102376438.97194,
    "parent_id": 235308.5
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/in/photo-category',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 413.854782167,
            'page' => 14,
            'q' => 'alias',
            'level' => 2.699197,
            'limit' => 102376438.97194,
            'parent_id' => 235308.5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/in/photo-category"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 413.854782167,
    "page": 14,
    "q": "alias",
    "level": 2.699197,
    "limit": 102376438.97194,
    "parent_id": 235308.5
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/photo-category

URL Parameters

ver string

Body Parameters

id number optional

page number optional

Must be at least 1.

q string optional

level number optional

limit number optional

parent_id number optional

GET api/{ver}/photo-set/{id}/items

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptatem/photo-set/890/items" \
    --header "Content-Type: application/json" \
    --data "{
    "media_id": 18,
    "limit": 14,
    "page": 59
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptatem/photo-set/890/items',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'media_id' => 18,
            'limit' => 14,
            'page' => 59,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatem/photo-set/890/items"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "media_id": 18,
    "limit": 14,
    "page": 59
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/photo-set/{id}/items

URL Parameters

ver string

id string

The ID of the photo set.

Body Parameters

media_id integer optional

limit integer optional

Must be at least 1. Must not be greater than 20.

page integer optional

Must be at least 1.

Display the specified resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/doloremque/photo-set/27"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/doloremque/photo-set/27');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/doloremque/photo-set/27"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/photo-tag

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aut/photo-tag" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 1941.6397
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aut/photo-tag',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 1941.6397,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/photo-tag"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 1941.6397
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/photo-tag

Example request:

curl --request POST \
    "http://localhost/api/v1/api/ex/photo-tag" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 13080734,
    "tag_user_id": 46,
    "px": 33,
    "py": 52
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/ex/photo-tag',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 13080734.0,
            'tag_user_id' => 46.0,
            'px' => 33,
            'py' => 52,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ex/photo-tag"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 13080734,
    "tag_user_id": 46,
    "px": 33,
    "py": 52
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/photo-tag

URL Parameters

ver string

Body Parameters

item_id number

tag_user_id number

px number optional

Must be at least 0.

py number optional

Must be at least 0.

DELETE api/{ver}/photo-tag/{id}

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/esse/photo-tag/815805868"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/esse/photo-tag/815805868');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/esse/photo-tag/815805868"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/photo/approve/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/nemo/photo/approve/6"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/nemo/photo/approve/6');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nemo/photo/approve/6"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

Display the specified resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptas/photo/download/517"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/voluptas/photo/download/517');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/photo/download/517"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/photo/feature/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/consequatur/photo/feature/872054" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "1"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/consequatur/photo/feature/872054',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consequatur/photo/feature/872054"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "1"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/photo/form/{id?}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptates/photo/form/336" \
    --header "Content-Type: application/json" \
    --data "{
    "owner_id": 5212010.4389489
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptates/photo/form/336',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'owner_id' => 5212010.4389489,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptates/photo/form/336"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "owner_id": 5212010.4389489
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/photo/parent-avatar/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/a/photo/parent-avatar/375359"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/a/photo/parent-avatar/375359');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/a/photo/parent-avatar/375359"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/photo/parent-cover/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/velit/photo/parent-cover/3059"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/velit/photo/parent-cover/3059');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/velit/photo/parent-cover/3059"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/photo/profile-avatar/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/dicta/photo/profile-avatar/30"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/dicta/photo/profile-avatar/30');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dicta/photo/profile-avatar/30"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/photo/profile-cover/{id}

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/consequuntur/photo/profile-cover/31699" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": 11,
    "position": "voluptates"
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/consequuntur/photo/profile-cover/31699',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 11,
            'position' => 'voluptates',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consequuntur/photo/profile-cover/31699"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 11,
    "position": "voluptates"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/dolorem/photo/sponsor-in-feed/6" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": 8029698.8
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/dolorem/photo/sponsor-in-feed/6',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 8029698.8,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolorem/photo/sponsor-in-feed/6"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": 8029698.8
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/blanditiis/photo/sponsor/46" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "et"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/blanditiis/photo/sponsor/46',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/blanditiis/photo/sponsor/46"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "et"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display the specified resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sed/photo/29512"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/sed/photo/29512');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sed/photo/29512"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Remove the specified resource from storage.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/in/photo/804"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/in/photo/804');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/in/photo/804"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/photo/{photo}/edit

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/accusamus/photo/veniam/edit"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/accusamus/photo/veniam/edit');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/accusamus/photo/veniam/edit"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Poll

App name: Poll Version: 5.0.19 Author: phpFox Updated at: Aug 02, 2024

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ullam/poll" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "dolorem",
    "view": "et",
    "sort": "fugit",
    "sort_type": "ea",
    "when": "veritatis",
    "owner_id": 16,
    "user_id": 74329547.36639257,
    "page": 19,
    "limit": 22803254.1376946,
    "is_featured": 0
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ullam/poll',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'dolorem',
            'view' => 'et',
            'sort' => 'fugit',
            'sort_type' => 'ea',
            'when' => 'veritatis',
            'owner_id' => 16,
            'user_id' => 74329547.36639257,
            'page' => 19,
            'limit' => 22803254.1376946,
            'is_featured' => 0.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ullam/poll"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "dolorem",
    "view": "et",
    "sort": "fugit",
    "sort_type": "ea",
    "when": "veritatis",
    "owner_id": 16,
    "user_id": 74329547.36639257,
    "page": 19,
    "limit": 22803254.1376946,
    "is_featured": 0
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/poll

URL Parameters

ver string

Body Parameters

q string optional

view string optional

sort string optional

sort_type string optional

when string optional

owner_id integer optional

user_id number optional

page number optional

Must be at least 1.

limit number optional

is_featured number optional

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/pariatur/poll-result" \
    --header "Content-Type: application/json" \
    --data "{
    "poll_id": 56,
    "answer_id": 45,
    "page": 55,
    "limit": 299698.41417
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/pariatur/poll-result',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'poll_id' => 56,
            'answer_id' => 45,
            'page' => 55,
            'limit' => 299698.41417,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/pariatur/poll-result"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "poll_id": 56,
    "answer_id": 45,
    "page": 55,
    "limit": 299698.41417
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/poll-result

URL Parameters

ver string

Body Parameters

poll_id number optional

This field is required when answer_id is not present. Must be at least 1.

answer_id number optional

Must be at least 1.

page number optional

Must be at least 1.

limit number optional

Store a newly created resource in storage.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/maiores/poll-result" \
    --header "Content-Type: application/json" \
    --data "{
    "poll_id": 22,
    "answers": []
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/maiores/poll-result',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'poll_id' => 22,
            'answers' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/maiores/poll-result"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "poll_id": 22,
    "answers": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Update the specified resource in storage.

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/mollitia/poll-result/220135"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/mollitia/poll-result/220135');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/mollitia/poll-result/220135"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/poll/approve/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/sequi/poll/approve/515512449"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/sequi/poll/approve/515512449');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sequi/poll/approve/515512449"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/poll/feature/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/laborum/poll/feature/5" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "1"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/laborum/poll/feature/5',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/laborum/poll/feature/5"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "1"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/poll/integration-form

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/suscipit/poll/integration-form" \
    --header "Content-Type: application/json" \
    --data "{
    "poll_id": 29563546
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/suscipit/poll/integration-form',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'poll_id' => 29563546.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/suscipit/poll/integration-form"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "poll_id": 29563546
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/repellat/poll/search-form"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/repellat/poll/search-form');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/repellat/poll/search-form"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/quis/poll/sponsor-in-feed/2029" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": 447132.616
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/quis/poll/sponsor-in-feed/2029',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 447132.616,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quis/poll/sponsor-in-feed/2029"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": 447132.616
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/qui/poll/sponsor/43" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "enim"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/qui/poll/sponsor/43',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'enim',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/poll/sponsor/43"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "enim"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/poll/status-form

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/mollitia/poll/status-form"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/mollitia/poll/status-form');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/mollitia/poll/status-form"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Display the specified resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/veritatis/poll/06"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/veritatis/poll/06');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/veritatis/poll/06"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Remove the specified resource from storage.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/voluptatem/poll/4"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/voluptatem/poll/4');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatem/poll/4"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

Quiz

App name: Quiz Version: 5.0.18 Author: phpFox Updated at: Aug 02, 2024

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/vel/quiz" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "suscipit",
    "view": "ut",
    "sort": "omnis",
    "sort_type": "saepe",
    "when": "ut",
    "owner_id": 14,
    "user_id": 0.8,
    "page": 58,
    "limit": 9.6,
    "is_featured": 18597.5
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/vel/quiz',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'suscipit',
            'view' => 'ut',
            'sort' => 'omnis',
            'sort_type' => 'saepe',
            'when' => 'ut',
            'owner_id' => 14,
            'user_id' => 0.8,
            'page' => 58,
            'limit' => 9.6,
            'is_featured' => 18597.5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/vel/quiz"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "suscipit",
    "view": "ut",
    "sort": "omnis",
    "sort_type": "saepe",
    "when": "ut",
    "owner_id": 14,
    "user_id": 0.8,
    "page": 58,
    "limit": 9.6,
    "is_featured": 18597.5
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/quiz

URL Parameters

ver string

Body Parameters

q string optional

view string optional

sort string optional

sort_type string optional

when string optional

owner_id integer optional

user_id number optional

page number optional

Must be at least 1.

limit number optional

is_featured number optional

GET api/{ver}/quiz-question/view-plays

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quia/quiz-question/view-plays" \
    --header "Content-Type: application/json" \
    --data "{
    "question_id": 83503.8393682
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quia/quiz-question/view-plays',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'question_id' => 83503.8393682,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quia/quiz-question/view-plays"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "question_id": 83503.8393682
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quasi/quiz-result" \
    --header "Content-Type: application/json" \
    --data "{
    "quiz_id": 73,
    "page": 31,
    "limit": 762004122.37
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quasi/quiz-result',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'quiz_id' => 73,
            'page' => 31,
            'limit' => 762004122.37,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quasi/quiz-result"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "quiz_id": 73,
    "page": 31,
    "limit": 762004122.37
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/quiz-result/view-individual-play

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/velit/quiz-result/view-individual-play" \
    --header "Content-Type: application/json" \
    --data "{
    "quiz_id": 6,
    "user_id": 42
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/velit/quiz-result/view-individual-play',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'quiz_id' => 6,
            'user_id' => 42,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/velit/quiz-result/view-individual-play"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "quiz_id": 6,
    "user_id": 42
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/quiz/approve/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/sint/quiz/approve/90"

$client = new \GuzzleHttp\Client();
$response = $client->patch('http://localhost/api/v1/api/sint/quiz/approve/90');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sint/quiz/approve/90"
);

fetch(url, {
    method: "PATCH",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/quiz/feature/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/eligendi/quiz/feature/3793" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "1"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/eligendi/quiz/feature/3793',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eligendi/quiz/feature/3793"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "1"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dolorem/quiz/search-form"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/dolorem/quiz/search-form');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolorem/quiz/search-form"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/nulla/quiz/sponsor-in-feed/2609" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": 3397.677339475
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/nulla/quiz/sponsor-in-feed/2609',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 3397.677339475,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nulla/quiz/sponsor-in-feed/2609"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": 3397.677339475
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/adipisci/quiz/sponsor/017" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "eveniet"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/adipisci/quiz/sponsor/017',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'eveniet',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/adipisci/quiz/sponsor/017"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "eveniet"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display the specified resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/libero/quiz/988"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/libero/quiz/988');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/libero/quiz/988"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Remove the specified resource from storage.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/asperiores/quiz/8"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/asperiores/quiz/8');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/asperiores/quiz/8"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

Reactions

App name: Reactions Version: 5.0.16 Author: phpFox Updated at: Aug 02, 2024

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/sapiente/like" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 63.4548,
    "item_type": "aliquam"
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/sapiente/like',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 63.4548,
            'item_type' => 'aliquam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sapiente/like"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 63.4548,
    "item_type": "aliquam"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ad/like" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 412622115.139,
    "item_type": "fugit",
    "react_id": 9.8548,
    "page": 37,
    "limit": 55
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ad/like',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 412622115.139,
            'item_type' => 'fugit',
            'react_id' => 9.8548,
            'page' => 37,
            'limit' => 55,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ad/like"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 412622115.139,
    "item_type": "fugit",
    "react_id": 9.8548,
    "page": 37,
    "limit": 55
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/like

URL Parameters

ver string

Body Parameters

item_id number

item_type string

react_id number optional

page number optional

Must be at least 1.

limit number optional

Must be at least 10.

Store a newly created resource in storage.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/consectetur/like" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 2798998.550258514,
    "item_type": "fuga",
    "reaction_id": 126915773.63
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/consectetur/like',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 2798998.550258514,
            'item_type' => 'fuga',
            'reaction_id' => 126915773.63,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consectetur/like"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 2798998.550258514,
    "item_type": "fuga",
    "reaction_id": 126915773.63
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/like-tabs

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptas/like-tabs" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 27,
    "item_type": "fugiat"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptas/like-tabs',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 27,
            'item_type' => 'fugiat',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/like-tabs"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 27,
    "item_type": "fugiat"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/veritatis/like/75" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/veritatis/like/75',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/veritatis/like/75"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/consequatur/preaction" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/consequatur/preaction',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consequatur/preaction"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sint/preaction/get-reacted-lists" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 49249.065812776,
    "item_type": "sit",
    "react_id": 498.57759,
    "page": 83,
    "limit": 68
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sint/preaction/get-reacted-lists',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 49249.065812776,
            'item_type' => 'sit',
            'react_id' => 498.57759,
            'page' => 83,
            'limit' => 68,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sint/preaction/get-reacted-lists"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 49249.065812776,
    "item_type": "sit",
    "react_id": 498.57759,
    "page": 83,
    "limit": 68
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/preaction/get-reacted-lists

URL Parameters

ver string

Body Parameters

item_id number

item_type string

react_id number optional

page number optional

Must be at least 1.

limit number optional

Must be at least 10.

GET api/{ver}/preaction/reaction-tabs

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/excepturi/preaction/reaction-tabs" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 25,
    "item_type": "commodi"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/excepturi/preaction/reaction-tabs',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 25,
            'item_type' => 'commodi',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/excepturi/preaction/reaction-tabs"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 25,
    "item_type": "commodi"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/perspiciatis/reaction" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/perspiciatis/reaction',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/perspiciatis/reaction"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Report

App name: Report Version: 5.0.15 Author: phpFox Updated at: Aug 02, 2024

Store a new report.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/ut/report" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "reason": 178417.85386579,
    "feedback": "voluptatem",
    "item_id": 46.85349,
    "item_type": "et"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/ut/report',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'reason' => 178417.85386579,
            'feedback' => 'voluptatem',
            'item_id' => 46.85349,
            'item_type' => 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/report"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "reason": 178417.85386579,
    "feedback": "voluptatem",
    "item_id": 46.85349,
    "item_type": "et"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/report

URL Parameters

ver string

Body Parameters

reason number

feedback string optional

item_id number

item_type string

Browse reports.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/libero/report-owner" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "owner_id": 1.80240315,
    "sort_type": "quis",
    "page": 65,
    "limit": 118620.486014248
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/libero/report-owner',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'owner_id' => 1.80240315,
            'sort_type' => 'quis',
            'page' => 65,
            'limit' => 118620.486014248,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/libero/report-owner"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "owner_id": 1.80240315,
    "sort_type": "quis",
    "page": 65,
    "limit": 118620.486014248
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/report-owner

URL Parameters

ver string

Body Parameters

owner_id number

sort_type string optional

page number optional

Must be at least 1.

limit number optional

Post a report to owner.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/qui/report-owner" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "reason": 10256074.4,
    "feedback": "velit",
    "item_id": 47,
    "item_type": "sapiente"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/qui/report-owner',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'reason' => 10256074.4,
            'feedback' => 'velit',
            'item_id' => 47,
            'item_type' => 'sapiente',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/report-owner"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "reason": 10256074.4,
    "feedback": "velit",
    "item_id": 47,
    "item_type": "sapiente"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/report-owner

URL Parameters

ver string

Body Parameters

reason number optional

feedback string optional

item_id number

Must be at least 1.

item_type string

Get report form.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/fugiat/report-owner/form" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 70,
    "item_type": "voluptatem"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/fugiat/report-owner/form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 70,
            'item_type' => 'voluptatem',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/fugiat/report-owner/form"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 70,
    "item_type": "voluptatem"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/report-owner/reporters/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dolores/report-owner/reporters/85049168" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/dolores/report-owner/reporters/85049168',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolores/report-owner/reporters/85049168"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Update a report.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/aut/report-owner/15" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "keep_post": "sit"
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/aut/report-owner/15',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'keep_post' => 'sit',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/report-owner/15"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "keep_post": "sit"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Get report form.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ut/report/form" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 20,
    "item_type": "at"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ut/report/form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 20,
            'item_type' => 'at',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/report/form"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 20,
    "item_type": "at"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Get report form.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/qui/report/form/mobile" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 8,
    "item_type": "harum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/qui/report/form/mobile',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 8,
            'item_type' => 'harum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/report/form/mobile"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 8,
    "item_type": "harum"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Browse report reasons.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ratione/report/reason" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 13,
    "limit": 4804.8
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/ratione/report/reason',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 13,
            'limit' => 4804.8,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ratione/report/reason"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 13,
    "limit": 4804.8
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

SEO

App name: SEO Version: 5.0.12 Author: phpFox Updated at: Aug 02, 2024

GET api/{ver}/seo/meta

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/possimus/seo/meta"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/possimus/seo/meta');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/possimus/seo/meta"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/seo/meta

Example request:

curl --request POST \
    "http://localhost/api/v1/api/et/seo/meta"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/et/seo/meta');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/seo/meta"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

View item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/assumenda/seo/meta/blog.browse.home"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/assumenda/seo/meta/blog.browse.home');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/assumenda/seo/meta/blog.browse.home"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

SMS Gateway

App name: SMS Gateway Version: 5.0.10 Author: phpFox Updated at: Aug 02, 2024

notify.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/vel/sms/notify"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/vel/sms/notify');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/vel/sms/notify"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

Saved

App name: Saved Version: 5.0.18 Author: phpFox Updated at: Aug 02, 2024

Browse item.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/porro/saveditems" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "iure",
    "collection_id": 583232.3779,
    "sort_type": "voluptas",
    "open": "ut",
    "when": "beatae",
    "type": "aliquid",
    "page": 41,
    "limit": 42
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/porro/saveditems',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'iure',
            'collection_id' => 583232.3779,
            'sort_type' => 'voluptas',
            'open' => 'ut',
            'when' => 'beatae',
            'type' => 'aliquid',
            'page' => 41,
            'limit' => 42,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/porro/saveditems"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "iure",
    "collection_id": 583232.3779,
    "sort_type": "voluptas",
    "open": "ut",
    "when": "beatae",
    "type": "aliquid",
    "page": 41,
    "limit": 42
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/saveditems

URL Parameters

ver string

Body Parameters

q string optional

collection_id number optional

sort_type string optional

open string optional

when string optional

type string optional

page number optional

Must be at least 1.

limit number optional

Must be at least 10.

Create item.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/ut/saveditems" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 19943217.9734,
    "item_type": "aliquid",
    "in_feed": 177781.6,
    "saved_list_ids": [
        35975285.280567504
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/ut/saveditems',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 19943217.9734,
            'item_type' => 'aliquid',
            'in_feed' => 177781.6,
            'saved_list_ids' => [
                35975285.280567504,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/saveditems"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 19943217.9734,
    "item_type": "aliquid",
    "in_feed": 177781.6,
    "saved_list_ids": [
        35975285.280567504
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/saveditems

URL Parameters

ver string

Body Parameters

item_id number

item_type string

in_feed number

saved_list_ids number[] optional

Browse list.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/itaque/saveditems-collection" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 1,
    "limit": 63,
    "type": "ipsum",
    "saved_id": 862.9989957
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/itaque/saveditems-collection',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 1,
            'limit' => 63,
            'type' => 'ipsum',
            'saved_id' => 862.9989957,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/itaque/saveditems-collection"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 1,
    "limit": 63,
    "type": "ipsum",
    "saved_id": 862.9989957
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/saveditems-collection

URL Parameters

ver string

Body Parameters

page number optional

Must be at least 1.

limit number optional

Must be at least 5.

type string optional

saved_id number optional

Create list.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/sunt/saveditems-collection" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "name": "axtihvjetpqhxnvdob",
    "privacy": "ratione"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/sunt/saveditems-collection',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'axtihvjetpqhxnvdob',
            'privacy' => 'ratione',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sunt/saveditems-collection"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "axtihvjetpqhxnvdob",
    "privacy": "ratione"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/saveditems-collection/add-friend/{id}

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/et/saveditems-collection/add-friend/9505" \
    --header "Authorization: Bearer {accessToken}" \

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/et/saveditems-collection/add-friend/9505',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/saveditems-collection/add-friend/9505"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

View creation form.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sed/saveditems-collection/form" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sed/saveditems-collection/form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sed/saveditems-collection/form"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

View update form.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/eos/saveditems-collection/form/55" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/eos/saveditems-collection/form/55',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eos/saveditems-collection/form/55"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/saveditems-collection/item/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/est/saveditems-collection/item/31" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 45,
    "limit": 16,
    "type": "id",
    "saved_id": 1776909.04
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/est/saveditems-collection/item/31',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 45,
            'limit' => 16,
            'type' => 'id',
            'saved_id' => 1776909.04,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/est/saveditems-collection/item/31"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 45,
    "limit": 16,
    "type": "id",
    "saved_id": 1776909.04
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/saveditems-collection/item/{id}

URL Parameters

ver string

id string

The ID of the item.

Body Parameters

page number optional

Must be at least 1.

limit number optional

Must be at least 5.

type string optional

saved_id number optional

DELETE api/{ver}/saveditems-collection/leave-collection/{id}

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/aliquid/saveditems-collection/leave-collection/7965" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/aliquid/saveditems-collection/leave-collection/7965',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aliquid/saveditems-collection/leave-collection/7965"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/saveditems-collection/remove-member/{id}

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/hic/saveditems-collection/remove-member/400274" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": 827763857
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/hic/saveditems-collection/remove-member/400274',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 827763857.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/hic/saveditems-collection/remove-member/400274"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 827763857
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/saveditems-collection/view-friend/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aliquid/saveditems-collection/view-friend/540910" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aliquid/saveditems-collection/view-friend/540910',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aliquid/saveditems-collection/view-friend/540910"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

View list.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptatem/saveditems-collection/41" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptatem/saveditems-collection/41',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatem/saveditems-collection/41"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Update list.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/blanditiis/saveditems-collection/9" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "name": "fdqosuqnoxzztpa"
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/blanditiis/saveditems-collection/9',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'fdqosuqnoxzztpa',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/blanditiis/saveditems-collection/9"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "fdqosuqnoxzztpa"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/saveditems-collection/{id}

PATCH api/{ver}/saveditems-collection/{id}

URL Parameters

ver string

id string

The ID of the saveditems collection.

Body Parameters

name string

Must not be greater than 128 characters.

privacy string optional

Remove list.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/repellat/saveditems-collection/8" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/repellat/saveditems-collection/8',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/repellat/saveditems-collection/8"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Move item.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/recusandae/saveditems/collection" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 3280048.521064,
    "collection_ids": [
        475.9166805
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/recusandae/saveditems/collection',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 3280048.521064,
            'collection_ids' => [
                475.9166805,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/recusandae/saveditems/collection"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 3280048.521064,
    "collection_ids": [
        475.9166805
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/saveditems/collection/{list_id}/save/{saved_id}

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/iste/saveditems/collection/omnis/save/aliquid" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/iste/saveditems/collection/omnis/save/aliquid',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/iste/saveditems/collection/omnis/save/aliquid"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Browse tabs.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/possimus/saveditems/get-tab" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/possimus/saveditems/get-tab',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/possimus/saveditems/get-tab"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Mark as opened.

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/non/saveditems/read/1305" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "saved_id": 4.86588,
    "status": 116820768.84304188,
    "collection_id": 969.4
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/non/saveditems/read/1305',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'saved_id' => 4.86588,
            'status' => 116820768.84304188,
            'collection_id' => 969.4,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/non/saveditems/read/1305"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "saved_id": 4.86588,
    "status": 116820768.84304188,
    "collection_id": 969.4
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PATCH api/{ver}/saveditems/read/{id}

URL Parameters

ver string

id string

The ID of the read.

Body Parameters

saved_id number

status number optional

collection_id number optional

Create item.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/sunt/saveditems/save" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 522423.95908,
    "item_type": "non",
    "in_feed": 704.28,
    "saved_list_ids": [
        54374.4
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/sunt/saveditems/save',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 522423.95908,
            'item_type' => 'non',
            'in_feed' => 704.28,
            'saved_list_ids' => [
                54374.4,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sunt/saveditems/save"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 522423.95908,
    "item_type": "non",
    "in_feed": 704.28,
    "saved_list_ids": [
        54374.4
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/saveditems/save

URL Parameters

ver string

Body Parameters

item_id number

item_type string

in_feed number

saved_list_ids number[] optional

Unsave item.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/dolorum/saveditems/unsave" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_id": 74.383608,
    "item_type": "consequatur"
}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/dolorum/saveditems/unsave',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_id' => 74.383608,
            'item_type' => 'consequatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolorum/saveditems/unsave"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_id": 74.383608,
    "item_type": "consequatur"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View item.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aut/saveditems/92196" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aut/saveditems/92196',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/saveditems/92196"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Update item.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/minima/saveditems/35936" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "is_unopened": 198.690598795,
    "saved_list_ids": [
        5414.79161193
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/minima/saveditems/35936',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'is_unopened' => 198.690598795,
            'saved_list_ids' => [
                5414.79161193,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/minima/saveditems/35936"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "is_unopened": 198.690598795,
    "saved_list_ids": [
        5414.79161193
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/saveditems/{id}

PATCH api/{ver}/saveditems/{id}

URL Parameters

ver string

id string

The ID of the saveditem.

Body Parameters

is_unopened number optional

saved_list_ids number[] optional

Remove item.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/eligendi/saveditems/80" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/eligendi/saveditems/80',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eligendi/saveditems/80"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Search

App name: Search Version: 5.0.13 Author: phpFox Updated at: Aug 02, 2024

Display a listing of the resource.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quia/search" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "ujscggdfvafbxlcasorgaleulgnrfiewsteadvhdzcbtbv",
    "owner_id": 0,
    "from": "similique",
    "hashtag": "laboriosam",
    "limit": 89,
    "last_search_id": 12,
    "view": "ipsam"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quia/search',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'ujscggdfvafbxlcasorgaleulgnrfiewsteadvhdzcbtbv',
            'owner_id' => 0.0,
            'from' => 'similique',
            'hashtag' => 'laboriosam',
            'limit' => 89,
            'last_search_id' => 12,
            'view' => 'ipsam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quia/search"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "ujscggdfvafbxlcasorgaleulgnrfiewsteadvhdzcbtbv",
    "owner_id": 0,
    "from": "similique",
    "hashtag": "laboriosam",
    "limit": 89,
    "last_search_id": 12,
    "view": "ipsam"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/search

URL Parameters

ver string

Body Parameters

q string

Must be at least 2 characters.

owner_id number optional

from string optional

hashtag string optional

related_comment_friend_only string optional

is_hashtag string optional

when string optional

limit number optional

Must be at least 2.

last_search_id number optional

Must be at least 1.

view string optional

GET api/{ver}/search/group

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/repudiandae/search/group" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "qtwqaqivckroguodgsvhmbadsxmwlfcafnobcdstzbfiowbwrkccffqpvozmgoelxbqqqephjjsuzcjkzv",
    "owner_id": 133.182002041,
    "from": "laborum",
    "hashtag": "vel"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/repudiandae/search/group',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'qtwqaqivckroguodgsvhmbadsxmwlfcafnobcdstzbfiowbwrkccffqpvozmgoelxbqqqephjjsuzcjkzv',
            'owner_id' => 133.182002041,
            'from' => 'laborum',
            'hashtag' => 'vel',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/repudiandae/search/group"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "qtwqaqivckroguodgsvhmbadsxmwlfcafnobcdstzbfiowbwrkccffqpvozmgoelxbqqqephjjsuzcjkzv",
    "owner_id": 133.182002041,
    "from": "laborum",
    "hashtag": "vel"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/search/group

URL Parameters

ver string

Body Parameters

q string

Must be at least 2 characters.

owner_id number optional

from string optional

hashtag string optional

related_comment_friend_only string optional

is_hashtag string optional

when string optional

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/eveniet/search/hashtag/trending" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 44,
    "limit": 3
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/eveniet/search/hashtag/trending',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 44,
            'limit' => 3,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eveniet/search/hashtag/trending"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 44,
    "limit": 3
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View Suggestions.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/saepe/search/suggestion" \
    --header "Content-Type: application/json" \
    --data "{
    "limit": 15,
    "q": "consequatur"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/saepe/search/suggestion',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'limit' => 15,
            'q' => 'consequatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/saepe/search/suggestion"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "limit": 15,
    "q": "consequatur"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

App name: Social Connect Version: 5.0.13 Author: phpFox Updated at: Aug 02, 2024

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sit/socialite/callback/sit" \
    --header "Content-Type: application/json" \
    --data "{
    "code": "incidunt",
    "token": "tempore",
    "code_verifier": "quasi",
    "display_name": "repudiandae"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sit/socialite/callback/sit',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'code' => 'incidunt',
            'token' => 'tempore',
            'code_verifier' => 'quasi',
            'display_name' => 'repudiandae',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sit/socialite/callback/sit"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "code": "incidunt",
    "token": "tempore",
    "code_verifier": "quasi",
    "display_name": "repudiandae"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/socialite/callback/{provider}

URL Parameters

ver string

provider string

Body Parameters

code string optional

token string optional

code_verifier string optional

display_name string optional

Example request:

curl --request POST \
    "http://localhost/api/v1/api/iusto/socialite/invite/verify" \
    --header "Content-Type: application/json" \
    --data "{
    "hash": "et"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/iusto/socialite/invite/verify',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'hash' => 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/iusto/socialite/invite/verify"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "hash": "et"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptatum/socialite/login/necessitatibus" \
    --header "Content-Type: application/json" \
    --data "{
    "provider": "consequatur"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptatum/socialite/login/necessitatibus',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'provider' => 'consequatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatum/socialite/login/necessitatibus"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "provider": "consequatur"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Static Page

App name: Static Page Version: 5.0.12 Author: phpFox Updated at: Aug 02, 2024

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/cum/static-page"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/cum/static-page');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/cum/static-page"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/qui/static-page"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/qui/static-page');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/static-page"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

View item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptas/static-page/page/67635372"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/voluptas/static-page/page/67635372');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/static-page/page/67635372"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

View item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/beatae/static-page/1"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/beatae/static-page/1');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/beatae/static-page/1"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Update item.

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/ea/static-page/344"

$client = new \GuzzleHttp\Client();
$response = $client->put('http://localhost/api/v1/api/ea/static-page/344');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ea/static-page/344"
);

fetch(url, {
    method: "PUT",
}).then(response => response.json());

Received response:

Request failed with error:

Delete item.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/ut/static-page/684"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/ut/static-page/684');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/static-page/684"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

Status Background

App name: Status Background Version: 5.0.17 Author: phpFox Updated at: Aug 02, 2024

Get background.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/illum/bgs-background" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "collection_id": 1714.96482327,
    "page": 26,
    "limit": 0.1527
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/illum/bgs-background',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'collection_id' => 1714.96482327,
            'page' => 26,
            'limit' => 0.1527,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/illum/bgs-background"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "collection_id": 1714.96482327,
    "page": 26,
    "limit": 0.1527
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Browse collection.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/eius/pstatusbg-collection" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 51,
    "limit": 105318946.922
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/eius/pstatusbg-collection',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 51,
            'limit' => 105318946.922,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eius/pstatusbg-collection"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 51,
    "limit": 105318946.922
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Create background.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/et/pstatusbg-collection" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "rnx",
    "is_active": 480196671.078685,
    "is_default": 30.97,
    "background_temp_file": [
        109648.8
    ]
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/et/pstatusbg-collection',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'rnx',
            'is_active' => 480196671.078685,
            'is_default' => 30.97,
            'background_temp_file' => [
                109648.8,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/pstatusbg-collection"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "rnx",
    "is_active": 480196671.078685,
    "is_default": 30.97,
    "background_temp_file": [
        109648.8
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/pstatusbg-collection

URL Parameters

ver string

Body Parameters

title string

Must be between 3 and 255 characters.

is_active number optional

is_default number optional

background_temp_file number[] optional

View background.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sit/pstatusbg-collection/70" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sit/pstatusbg-collection/70',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sit/pstatusbg-collection/70"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Sticker

App name: Sticker Version: 5.1.11 Author: phpFox Updated at: Aug 02, 2024

Browse item.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/pariatur/sticker" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "set_id": 8262196.0759,
    "page": 12,
    "limit": 43.8786617
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/pariatur/sticker',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'set_id' => 8262196.0759,
            'page' => 12,
            'limit' => 43.8786617,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/pariatur/sticker"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "set_id": 8262196.0759,
    "page": 12,
    "limit": 43.8786617
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/sticker/recent

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/corporis/sticker/recent" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 11,
    "limit": 1225.5
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/corporis/sticker/recent',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 11,
            'limit' => 1225.5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/corporis/sticker/recent"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 11,
    "limit": 1225.5
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/sticker/recent

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/et/sticker/recent" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sticker_id": 393.625218
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/et/sticker/recent',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sticker_id' => 393.625218,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/sticker/recent"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sticker_id": 393.625218
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Browse sticker.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/numquam/sticker/sticker-set" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "view": "autem",
    "page": 1,
    "limit": 50308173.7
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/numquam/sticker/sticker-set',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'view' => 'autem',
            'page' => 1,
            'limit' => 50308173.7,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/numquam/sticker/sticker-set"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "view": "autem",
    "page": 1,
    "limit": 50308173.7
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Active sticker set.

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/qui/sticker/sticker-set/active/qui" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "active": 231968806.24873182
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/qui/sticker/sticker-set/active/qui',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'active' => 231968806.24873182,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/sticker/sticker-set/active/qui"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "active": 231968806.24873182
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/sticker/sticker-set/default/{sticker_set}

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/a/sticker/sticker-set/default/et" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/a/sticker/sticker-set/default/et',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/a/sticker/sticker-set/default/et"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/sticker/sticker-set/user

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/rerum/sticker/sticker-set/user" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 4.3
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/rerum/sticker/sticker-set/user',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 4.3,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/rerum/sticker/sticker-set/user"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 4.3
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/sticker/sticker-set/user/{id}

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/officia/sticker/sticker-set/user/34" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/officia/sticker/sticker-set/user/34',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/officia/sticker/sticker-set/user/34"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

View sticker set.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/exercitationem/sticker/sticker-set/8" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/exercitationem/sticker/sticker-set/8',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/exercitationem/sticker/sticker-set/8"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Delete item.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/veniam/sticker/572" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/veniam/sticker/572',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/veniam/sticker/572"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Story

App name: Story Version: 5.1.10 Author: phpFox Updated at: Aug 02, 2024

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/harum/story" \
    --header "Content-Type: application/json" \
    --data "{
    "privacy": "dolore",
    "lifespan": 22,
    "text": "at",
    "font_style": "aperiam",
    "background_id": 18,
    "type": "illo",
    "file": {
        "temp_file": 416.02561677
    },
    "thumb_file": {
        "temp_file": 18.84526636
    },
    "duration": 12
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/harum/story',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'privacy' => 'dolore',
            'lifespan' => 22,
            'text' => 'at',
            'font_style' => 'aperiam',
            'background_id' => 18,
            'type' => 'illo',
            'file' => [
                'temp_file' => 416.02561677,
            ],
            'thumb_file' => [
                'temp_file' => 18.84526636,
            ],
            'duration' => 12,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/harum/story"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "privacy": "dolore",
    "lifespan": 22,
    "text": "at",
    "font_style": "aperiam",
    "background_id": 18,
    "type": "illo",
    "file": {
        "temp_file": 416.02561677
    },
    "thumb_file": {
        "temp_file": 18.84526636
    },
    "duration": 12
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/story

URL Parameters

ver string

Body Parameters

privacy string

lifespan integer optional

Must be at least 1. Must not be greater than 24.

text string optional

font_style string optional

background_id integer optional

extra object optional

type string optional

file object optional

file.temp_file number optional

This field is required when file is present.

thumb_file object optional

thumb_file.temp_file number optional

This field is required when thumb_file is present.

duration number optional

Must not be greater than 30.

GET api/{ver}/story-archive

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/perspiciatis/story-archive" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": 14,
    "story_id": 7261.9,
    "page": 55,
    "date": "2024-08-02T08:10:43",
    "from_date": "2024-08-02T08:10:43",
    "to_date": "2024-08-02T08:10:43",
    "limit": 92380.20211
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/perspiciatis/story-archive',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 14,
            'story_id' => 7261.9,
            'page' => 55,
            'date' => '2024-08-02T08:10:43',
            'from_date' => '2024-08-02T08:10:43',
            'to_date' => '2024-08-02T08:10:43',
            'limit' => 92380.20211,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/perspiciatis/story-archive"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 14,
    "story_id": 7261.9,
    "page": 55,
    "date": "2024-08-02T08:10:43",
    "from_date": "2024-08-02T08:10:43",
    "to_date": "2024-08-02T08:10:43",
    "limit": 92380.20211
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/story-archive

URL Parameters

ver string

Body Parameters

user_id integer optional

story_id number optional

page number optional

Must be at least 1.

date string optional

Must be a valid date.

from_date string optional

Must be a valid date.

to_date string optional

Must be a valid date.

limit number optional

POST api/{ver}/story-archive

Example request:

curl --request POST \
    "http://localhost/api/v1/api/qui/story-archive" \
    --header "Content-Type: application/json" \
    --data "{
    "story_id": 45225.850135931
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/qui/story-archive',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'story_id' => 45225.850135931,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/story-archive"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "story_id": 45225.850135931
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/story-archive/setting

Example request:

curl --request POST \
    "http://localhost/api/v1/api/id/story-archive/setting"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/id/story-archive/setting');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/id/story-archive/setting"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/maiores/story-background" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 21,
    "limit": 5.3
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/maiores/story-background',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 21,
            'limit' => 5.3,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/maiores/story-background"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 21,
    "limit": 5.3
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sed/story-background/95"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/sed/story-background/95');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sed/story-background/95"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Store item

Example request:

curl --request POST \
    "http://localhost/api/v1/api/iure/story-reaction" \
    --header "Content-Type: application/json" \
    --data "{
    "story_id": 652679.213276,
    "reaction_id": 11679897.346
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/iure/story-reaction',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'story_id' => 652679.213276,
            'reaction_id' => 11679897.346,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/iure/story-reaction"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "story_id": 652679.213276,
    "reaction_id": 11679897.346
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/autem/story-view" \
    --header "Content-Type: application/json" \
    --data "{
    "story_id": 58.85788733,
    "page": 17,
    "limit": 117983.933347659
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/autem/story-view',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'story_id' => 58.85788733,
            'page' => 17,
            'limit' => 117983.933347659,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/autem/story-view"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "story_id": 58.85788733,
    "page": 17,
    "limit": 117983.933347659
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/laboriosam/story-view" \
    --header "Content-Type: application/json" \
    --data "{
    "story_id": 3030.42858704
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/laboriosam/story-view',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'story_id' => 3030.42858704,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/laboriosam/story-view"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "story_id": 3030.42858704
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/story/callback/{provider}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/consequatur/story/callback/consectetur"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/consequatur/story/callback/consectetur');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consequatur/story/callback/consectetur"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ut/story/31377495"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/ut/story/31377495');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/story/31377495"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Delete item.

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/recusandae/story/3872"

$client = new \GuzzleHttp\Client();
$response = $client->delete('http://localhost/api/v1/api/recusandae/story/3872');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/recusandae/story/3872"
);

fetch(url, {
    method: "DELETE",
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/nesciunt/user_story" \
    --header "Content-Type: application/json" \
    --data "{
    "related_user_id": 13,
    "user_id": 12,
    "page": 48,
    "limit": 3850106.88900004
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/nesciunt/user_story',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'related_user_id' => 13,
            'user_id' => 12,
            'page' => 48,
            'limit' => 3850106.88900004,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nesciunt/user_story"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "related_user_id": 13,
    "user_id": 12,
    "page": 48,
    "limit": 3850106.88900004
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/user_story

URL Parameters

ver string

Body Parameters

related_user_id integer optional

user_id integer optional

page number optional

Must be at least 1.

limit number optional

Subscription

App name: Subscription Version: 5.0.18 Author: phpFox Updated at: Aug 02, 2024

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quas/subscription-comparison"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/quas/subscription-comparison');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quas/subscription-comparison"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/consequuntur/subscription-invoice" \
    --header "Content-Type: application/json" \
    --data "{
    "limit": 1,
    "page": 76
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/consequuntur/subscription-invoice',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'limit' => 1,
            'page' => 76,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consequuntur/subscription-invoice"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "limit": 1,
    "page": 76
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Store item.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/neque/subscription-invoice" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 5.3253,
    "renew_type": "molestiae",
    "payment_gateway": 54596.92628894,
    "previous_process_child_id": "facilis",
    "form_name": "veritatis"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/neque/subscription-invoice',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 5.3253,
            'renew_type' => 'molestiae',
            'payment_gateway' => 54596.92628894,
            'previous_process_child_id' => 'facilis',
            'form_name' => 'veritatis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/neque/subscription-invoice"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 5.3253,
    "renew_type": "molestiae",
    "payment_gateway": 54596.92628894,
    "previous_process_child_id": "facilis",
    "form_name": "veritatis"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/subscription-invoice

URL Parameters

ver string

Body Parameters

id number

renew_type string optional

payment_gateway number

previous_process_child_id string optional

form_name string optional

GET api/{ver}/subscription-invoice/cancel-form/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/molestiae/subscription-invoice/cancel-form/73"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/molestiae/subscription-invoice/cancel-form/73');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/molestiae/subscription-invoice/cancel-form/73"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/subscription-invoice/cancel/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/voluptatum/subscription-invoice/cancel/555" \
    --header "Content-Type: application/json" \
    --data "{
    "reason_id": 50824.710738258
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/voluptatum/subscription-invoice/cancel/555',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'reason_id' => 50824.710738258,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatum/subscription-invoice/cancel/555"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "reason_id": 50824.710738258
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/subscription-invoice/change-invoice/{id}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/vero/subscription-invoice/change-invoice/7"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/vero/subscription-invoice/change-invoice/7');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/vero/subscription-invoice/change-invoice/7"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/subscription-invoice/payment-form/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dolor/subscription-invoice/payment-form/7" \
    --header "Content-Type: application/json" \
    --data "{
    "renew_type": "provident",
    "action_type": "dolorum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/dolor/subscription-invoice/payment-form/7',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'renew_type' => 'provident',
            'action_type' => 'dolorum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolor/subscription-invoice/payment-form/7"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "renew_type": "provident",
    "action_type": "dolorum"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/subscription-invoice/payment-form/{id}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/quis/subscription-invoice/payment-form/9756" \
    --header "Content-Type: application/json" \
    --data "{
    "renew_type": "ea",
    "action_type": "nostrum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/quis/subscription-invoice/payment-form/9756',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'renew_type' => 'ea',
            'action_type' => 'nostrum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quis/subscription-invoice/payment-form/9756"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "renew_type": "ea",
    "action_type": "nostrum"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/subscription-invoice/renew-form/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quae/subscription-invoice/renew-form/5"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/quae/subscription-invoice/renew-form/5');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quae/subscription-invoice/renew-form/5"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/subscription-invoice/renew-method-form/{id}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/culpa/subscription-invoice/renew-method-form/017786" \
    --header "Content-Type: application/json" \
    --data "{
    "renew_type": "et",
    "action_type": "voluptate"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/culpa/subscription-invoice/renew-method-form/017786',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'renew_type' => 'et',
            'action_type' => 'voluptate',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/culpa/subscription-invoice/renew-method-form/017786"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "renew_type": "et",
    "action_type": "voluptate"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/subscription-invoice/renew/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/in/subscription-invoice/renew/774" \
    --header "Content-Type: application/json" \
    --data "{
    "payment_gateway": 6616124.044
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/in/subscription-invoice/renew/774',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'payment_gateway' => 6616124.044,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/in/subscription-invoice/renew/774"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "payment_gateway": 6616124.044
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/subscription-invoice/upgrade/{id}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/qui/subscription-invoice/upgrade/6" \
    --header "Content-Type: application/json" \
    --data "{
    "payment_gateway": 3536651.1381,
    "action_type": "enim",
    "previous_process_child_id": "aut",
    "form_name": "perferendis"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/qui/subscription-invoice/upgrade/6',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'payment_gateway' => 3536651.1381,
            'action_type' => 'enim',
            'previous_process_child_id' => 'aut',
            'form_name' => 'perferendis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/subscription-invoice/upgrade/6"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "payment_gateway": 3536651.1381,
    "action_type": "enim",
    "previous_process_child_id": "aut",
    "form_name": "perferendis"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PATCH api/{ver}/subscription-invoice/upgrade/{id}

URL Parameters

ver string

id string

The ID of the upgrade.

Body Parameters

renew_type string optional

payment_gateway number

action_type string

previous_process_child_id string optional

form_name string optional

View item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/ut/subscription-invoice/9"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/ut/subscription-invoice/9');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/subscription-invoice/9"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Browse item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/suscipit/subscription-package" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "mollitia",
    "view": "aspernatur"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/suscipit/subscription-package',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'mollitia',
            'view' => 'aspernatur',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/suscipit/subscription-package"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "mollitia",
    "view": "aspernatur"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/subscription-package/payment-form/{id}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/placeat/subscription-package/payment-form/24" \
    --header "Content-Type: application/json" \
    --data "{
    "renew_type": "ut"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/placeat/subscription-package/payment-form/24',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'renew_type' => 'ut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/placeat/subscription-package/payment-form/24"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "renew_type": "ut"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/subscription-package/payment-form/{id}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/consequatur/subscription-package/payment-form/75" \
    --header "Content-Type: application/json" \
    --data "{
    "renew_type": "aperiam"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/consequatur/subscription-package/payment-form/75',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'renew_type' => 'aperiam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/consequatur/subscription-package/payment-form/75"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "renew_type": "aperiam"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/subscription-package/renew-form/{id}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/minus/subscription-package/renew-form/787"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/minus/subscription-package/renew-form/787');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/minus/subscription-package/renew-form/787"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

View item.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/nihil/subscription-package/0"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/nihil/subscription-package/0');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nihil/subscription-package/0"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

Theme

App name: Theme Version: 5.0.14 Author: phpFox Updated at: Aug 02, 2024

POST api/{ver}/layout/snippet/history/purge/{name}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/aut/layout/snippet/history/purge/nemo"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/aut/layout/snippet/history/purge/nemo');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/layout/snippet/history/purge/nemo"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/layout/snippet/history/{name}

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/numquam/layout/snippet/history/quia"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/numquam/layout/snippet/history/quia');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/numquam/layout/snippet/history/quia"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/layout/snippet/ping

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/repudiandae/layout/snippet/ping"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/repudiandae/layout/snippet/ping');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/repudiandae/layout/snippet/ping"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/layout/snippet/publish

Example request:

curl --request POST \
    "http://localhost/api/v1/api/quia/layout/snippet/publish"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/quia/layout/snippet/publish');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quia/layout/snippet/publish"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/layout/snippet/purge

Example request:

curl --request POST \
    "http://localhost/api/v1/api/odit/layout/snippet/purge"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/odit/layout/snippet/purge');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/odit/layout/snippet/purge"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/layout/snippet/revert/{id}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/velit/layout/snippet/revert/7"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/velit/layout/snippet/revert/7');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/velit/layout/snippet/revert/7"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

Store snippet layout.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/voluptas/layout/snippet/theme" \
    --header "Content-Type: application/json" \
    --data "{
    "theme": "aperiam",
    "name": "saepe",
    "variant": "porro",
    "files": [],
    "active": true
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/voluptas/layout/snippet/theme',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'theme' => 'aperiam',
            'name' => 'saepe',
            'variant' => 'porro',
            'files' => [],
            'active' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/layout/snippet/theme"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "theme": "aperiam",
    "name": "saepe",
    "variant": "porro",
    "files": [],
    "active": true
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/layout/snippet/theme

URL Parameters

ver string

Body Parameters

theme string

name string optional

variant string optional

files object

active boolean optional

Store snippet layout.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/nobis/layout/snippet/variant" \
    --header "Content-Type: application/json" \
    --data "{
    "theme": "error",
    "variant": "illo",
    "files": [],
    "active": true
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/nobis/layout/snippet/variant',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'theme' => 'error',
            'variant' => 'illo',
            'files' => [],
            'active' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nobis/layout/snippet/variant"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "theme": "error",
    "variant": "illo",
    "files": [],
    "active": true
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/layout/snippet/variant

URL Parameters

ver string

Body Parameters

theme string

variant string

files object

active boolean optional

User

App name: User Version: 5.1.13 Author: phpFox Updated at: Aug 02, 2024

GET api/{ver}/account/blocked-user

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/nulla/account/blocked-user" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/nulla/account/blocked-user',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nulla/account/blocked-user"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/account/blocked-user

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/atque/account/blocked-user" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": "sunt"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/atque/account/blocked-user',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 'sunt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/atque/account/blocked-user"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": "sunt"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

DELETE api/{ver}/account/blocked-user/{id}

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/numquam/account/blocked-user/444" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/numquam/account/blocked-user/444',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/numquam/account/blocked-user/444"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/account/invisible

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/voluptatem/account/invisible" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/voluptatem/account/invisible',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptatem/account/invisible"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/account/invisible

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/tempora/account/invisible" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "invisible": 0
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/tempora/account/invisible',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'invisible' => 0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/tempora/account/invisible"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "invisible": 0
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/account/item-privacy

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/odio/account/item-privacy" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/odio/account/item-privacy',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/odio/account/item-privacy"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/account/item-privacy/{id?}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quo/account/item-privacy/3691" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 20.888192858
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quo/account/item-privacy/3691',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 20.888192858,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quo/account/item-privacy/3691"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 20.888192858
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/account/notification

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/id/account/notification" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "channel": "nisi"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/id/account/notification',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'channel' => 'nisi',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/id/account/notification"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "channel": "nisi"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/account/notification

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/soluta/account/notification" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "module_id": "fugit",
    "value": 8,
    "var_name": "vel",
    "channel": "earum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/soluta/account/notification',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'module_id' => 'fugit',
            'value' => 8,
            'var_name' => 'vel',
            'channel' => 'earum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/soluta/account/notification"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "module_id": "fugit",
    "value": 8,
    "var_name": "vel",
    "channel": "earum"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/account/notification

URL Parameters

ver string

Body Parameters

module_id string optional

value integer optional

var_name string optional

channel string

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/fugiat/account/profile-menu" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/fugiat/account/profile-menu',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/fugiat/account/profile-menu"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/maiores/account/profile-menu/45596" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 95416.2
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/maiores/account/profile-menu/45596',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 95416.2,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/maiores/account/profile-menu/45596"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 95416.2
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/account/profile-privacy

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/iure/account/profile-privacy" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/iure/account/profile-privacy',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/iure/account/profile-privacy"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/account/profile-privacy/{id?}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/magni/account/profile-privacy/82" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 156.941
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/magni/account/profile-privacy/82',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 156.941,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/magni/account/profile-privacy/82"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 156.941
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/account/setting

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/harum/account/setting" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/harum/account/setting',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/harum/account/setting"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/account/setting/video

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/nihil/account/setting/video" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/nihil/account/setting/video',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/nihil/account/setting/video"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/account/setting/video/{id}

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/laborum/account/setting/video/6481" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/laborum/account/setting/video/6481',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/laborum/account/setting/video/6481"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/account/timezone

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/corporis/account/timezone" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/corporis/account/timezone',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/corporis/account/timezone"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/auth/logout

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/animi/auth/logout" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/animi/auth/logout',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/animi/auth/logout"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/auth/profile

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/maiores/auth/profile" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/maiores/auth/profile',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/maiores/auth/profile"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

View current logged in user.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/culpa/me" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "resolution": "repellendus"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/culpa/me',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'resolution' => 'repellendus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/culpa/me"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resolution": "repellendus"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

MetaFox

Example request:

curl --request POST \
    "http://localhost/api/v1/api/ad/register" \
    --header "Content-Type: application/json" \
    --data "{
    "email": "[email protected]",
    "phone_number": "maxime",
    "password": "l-[y#3",
    "full_name": "ondn",
    "user_name": "tlmdphyvtmjhrmzrgrhhm",
    "agree": true,
    "code": "perferendis",
    "invite_code": "nostrum",
    "subscribe_notification": true
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/ad/register',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'email' => '[email protected]',
            'phone_number' => 'maxime',
            'password' => 'l-[y#3',
            'full_name' => 'ondn',
            'user_name' => 'tlmdphyvtmjhrmzrgrhhm',
            'agree' => true,
            'code' => 'perferendis',
            'invite_code' => 'nostrum',
            'subscribe_notification' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ad/register"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "[email protected]",
    "phone_number": "maxime",
    "password": "l-[y#3",
    "full_name": "ondn",
    "user_name": "tlmdphyvtmjhrmzrgrhhm",
    "agree": true,
    "code": "perferendis",
    "invite_code": "nostrum",
    "subscribe_notification": true
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/register

URL Parameters

ver string

Body Parameters

email string optional

This field is required when phone_number is not present. Must be a valid email address.

phone_number string optional

This field is required when email is not present.

password string

full_name string

Must be at least 3 characters. Must not be greater than 25 characters.

user_name string

Must be at least 5 characters. Must not be greater than 25 characters.

agree boolean

Must be accepted.

captcha string optional

code string optional

invite_code string optional

subscribe_notification boolean optional

Browse user.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/velit/user" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "labore",
    "view": "aut",
    "gender": 350124.50493,
    "page": 29,
    "limit": 735.2691909,
    "sort": "et",
    "sort_type": "laudantium",
    "country": "eapggcaaqpstizytzxsqzydrvtizcydflfuytzczcaq",
    "country_state_id": "esse",
    "city_code": "aut",
    "is_featured": 3980.053547639,
    "group": 1.330609
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/velit/user',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'labore',
            'view' => 'aut',
            'gender' => 350124.50493,
            'page' => 29,
            'limit' => 735.2691909,
            'sort' => 'et',
            'sort_type' => 'laudantium',
            'country' => 'eapggcaaqpstizytzxsqzydrvtizcydflfuytzczcaq',
            'country_state_id' => 'esse',
            'city_code' => 'aut',
            'is_featured' => 3980.053547639,
            'group' => 1.330609,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/velit/user"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "labore",
    "view": "aut",
    "gender": 350124.50493,
    "page": 29,
    "limit": 735.2691909,
    "sort": "et",
    "sort_type": "laudantium",
    "country": "eapggcaaqpstizytzxsqzydrvtizcydflfuytzczcaq",
    "country_state_id": "esse",
    "city_code": "aut",
    "is_featured": 3980.053547639,
    "group": 1.330609
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/user

URL Parameters

ver string

Body Parameters

q string optional

view string optional

gender number optional

page number optional

Must be at least 1.

limit number optional

sort string optional

sort_type string optional

country string optional

Must be at least 2 characters.

country_state_id string optional

city string optional

city_code string optional

is_featured number optional

group number optional

GET api/{ver}/user/account

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/vel/user/account" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/vel/user/account',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/vel/user/account"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/user/account/email-form

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/eveniet/user/account/email-form" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "resolution": "doloremque"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/eveniet/user/account/email-form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'resolution' => 'doloremque',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eveniet/user/account/email-form"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resolution": "doloremque"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/user/account/phone-number-form

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/rem/user/account/phone-number-form" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "resolution": "iste"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/rem/user/account/phone-number-form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'resolution' => 'iste',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/rem/user/account/phone-number-form"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "resolution": "iste"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/user/account/review-form

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/vero/user/account/review-form" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/vero/user/account/review-form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/vero/user/account/review-form"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/user/account/timezone-form

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/et/user/account/timezone-form" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/et/user/account/timezone-form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/user/account/timezone-form"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/user/activity

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/provident/user/activity" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/provident/user/activity',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/provident/user/activity"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Upload avatar.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/aut/user/avatar/illo" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "image_crop": "temporibus",
    "temp_file": 345.480401,
    "photo_id": 4605091.4
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/aut/user/avatar/illo',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'image_crop' => 'temporibus',
            'temp_file' => 345.480401,
            'photo_id' => 4605091.4,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/user/avatar/illo"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "image_crop": "temporibus",
    "temp_file": 345.480401,
    "photo_id": 4605091.4
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/user/avatar/{user}

URL Parameters

ver string

user string

Body Parameters

image_crop string

image string optional

temp_file number optional

photo_id number optional

Ban user.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/omnis/user/ban" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": 8.23615,
    "day": 63,
    "return_user_group": 68
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/omnis/user/ban',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 8.23615,
            'day' => 63,
            'return_user_group' => 68,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/omnis/user/ban"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 8.23615,
    "day": 63,
    "return_user_group": 68
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/user/ban

URL Parameters

ver string

Body Parameters

user_id number

day number

Must be at least 0.

reason string optional

return_user_group number

Must be at least 1.

Un-ban user.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/ut/user/ban/259" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/ut/user/ban/259',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/user/ban/259"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/user/city

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dignissimos/user/city" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "quis",
    "country": "xglhqhdqubsnmuplkecqogumvdmudnzm",
    "state": "aut",
    "city_code": "minima",
    "limit": 1
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/dignissimos/user/city',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'quis',
            'country' => 'xglhqhdqubsnmuplkecqogumvdmudnzm',
            'state' => 'aut',
            'city_code' => 'minima',
            'limit' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dignissimos/user/city"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "quis",
    "country": "xglhqhdqubsnmuplkecqogumvdmudnzm",
    "state": "aut",
    "city_code": "minima",
    "limit": 1
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/user/city

URL Parameters

ver string

Body Parameters

q string optional

country string optional

Must be at least 2 characters.

state string optional

city_code string optional

limit integer optional

Must be between 1 and 20.

GET api/{ver}/user/country/state

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/impedit/user/country/state" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "porro",
    "country": "mclkcslrssmhtqbnuvxvyrzzngnbxxkukhbywsmdpmvfxxwqbocsjchqfqzlpnyxjhrwrovib",
    "state": "numquam",
    "city_code": "recusandae",
    "limit": 1
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/impedit/user/country/state',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'porro',
            'country' => 'mclkcslrssmhtqbnuvxvyrzzngnbxxkukhbywsmdpmvfxxwqbocsjchqfqzlpnyxjhrwrovib',
            'state' => 'numquam',
            'city_code' => 'recusandae',
            'limit' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/impedit/user/country/state"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "porro",
    "country": "mclkcslrssmhtqbnuvxvyrzzngnbxxkukhbywsmdpmvfxxwqbocsjchqfqzlpnyxjhrwrovib",
    "state": "numquam",
    "city_code": "recusandae",
    "limit": 1
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/user/country/state

URL Parameters

ver string

Body Parameters

q string optional

country string optional

Must be at least 2 characters.

state string optional

city_code string optional

limit integer optional

Must be between 1 and 20.

Update cover.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/odit/user/cover/explicabo" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "temp_file": 12427.3531,
    "position": "dolorum"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/odit/user/cover/explicabo',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'temp_file' => 12427.3531,
            'position' => 'dolorum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/odit/user/cover/explicabo"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "temp_file": 12427.3531,
    "position": "dolorum"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/user/cover/{user}

URL Parameters

ver string

user string

Body Parameters

image string optional

temp_file number optional

position string optional

PATCH api/{ver}/user/feature/{id}

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/explicabo/user/feature/99" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "1"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/explicabo/user/feature/99',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/explicabo/user/feature/99"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "1"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Get user registration form.

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/harum/user/form"

$client = new \GuzzleHttp\Client();
$response = $client->get('http://localhost/api/v1/api/harum/user/form');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/harum/user/form"
);

fetch(url, {
    method: "GET",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/user/info/{user}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/molestiae/user/info/ut" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/molestiae/user/info/ut',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/molestiae/user/info/ut"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Logged in by email and password.

Example request:

curl --request POST \
    "http://localhost/api/v1/api/sint/user/login" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "username": "[email protected]",
    "password": "12345678"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/sint/user/login',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'username' => '[email protected]',
            'password' => '12345678',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sint/user/login"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "username": "[email protected]",
    "password": "12345678"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/user/password/edit/{resolution}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/sint/user/password/edit/corrupti" \
    --header "Content-Type: application/json" \
    --data "{
    "token": "odio",
    "user_id": 948998.96
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/sint/user/password/edit/corrupti',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'token' => 'odio',
            'user_id' => 948998.96,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sint/user/password/edit/corrupti"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "token": "odio",
    "user_id": 948998.96
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/user/password/logout-all

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/cumque/user/password/logout-all" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": 164053.825404699,
    "token": "id"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/cumque/user/password/logout-all',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 164053.825404699,
            'token' => 'id',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/cumque/user/password/logout-all"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 164053.825404699,
    "token": "id"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/user/password/request-method/{resolution}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/aperiam/user/password/request-method/nulla" \
    --header "Content-Type: application/json" \
    --data "{
    "email": "[email protected]"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/aperiam/user/password/request-method/nulla',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'email' => '[email protected]',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aperiam/user/password/request-method/nulla"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "[email protected]"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/user/password/request-verify/{resolution}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/qui/user/password/request-verify/occaecati" \
    --header "Content-Type: application/json" \
    --data "{
    "request_method": "necessitatibus",
    "user_id": 12.7903614
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/qui/user/password/request-verify/occaecati',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'request_method' => 'necessitatibus',
            'user_id' => 12.7903614,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/user/password/request-verify/occaecati"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "request_method": "necessitatibus",
    "user_id": 12.7903614
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/user/password/{resolution?}

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/exercitationem/user/password/maxime" \
    --header "Content-Type: application/json" \
    --data "{
    "user_id": 7.9736541,
    "token": "voluptatum",
    "new_password": "delectus"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/exercitationem/user/password/maxime',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user_id' => 7.9736541,
            'token' => 'voluptatum',
            'new_password' => 'delectus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/exercitationem/user/password/maxime"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 7.9736541,
    "token": "voluptatum",
    "new_password": "delectus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PATCH api/{ver}/user/password/{resolution?}

URL Parameters

ver string

resolution string optional

Body Parameters

user_id number

token string

new_password string

new_password_confirmation string optional

This field is required when new_password is present. The value and new_password must match.

logout_others string optional

GET api/{ver}/user/profile/form

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sunt/user/profile/form" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 37.036959189
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sunt/user/profile/form',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 37.036959189,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sunt/user/profile/form"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 37.036959189
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/user/profile/gender

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/temporibus/user/profile/gender" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "tempora",
    "limit": 15,
    "is_custom": 197663738
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/temporibus/user/profile/gender',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'tempora',
            'limit' => 15,
            'is_custom' => 197663738.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/temporibus/user/profile/gender"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "tempora",
    "limit": 15,
    "is_custom": 197663738
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/user/profile/gender

URL Parameters

ver string

Body Parameters

q string optional

limit number optional

Must be at least 10.

is_custom number optional

GET api/{ver}/user/quick-preview/{id}

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/eligendi/user/quick-preview/30" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/eligendi/user/quick-preview/30',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/eligendi/user/quick-preview/30"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/user/refresh

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/quas/user/refresh" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "refresh_token": "numquam"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/quas/user/refresh',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'refresh_token' => 'numquam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quas/user/refresh"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "refresh_token": "numquam"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

PUT api/{ver}/user/remove-cover/{id?}

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/quia/user/remove-cover/5554" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/quia/user/remove-cover/5554',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quia/user/remove-cover/5554"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Browse shortcuts.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/suscipit/user/shortcut" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 15,
    "limit": 5588776.1852
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/suscipit/user/shortcut',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 15,
            'limit' => 5588776.1852,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/suscipit/user/shortcut"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 15,
    "limit": 5588776.1852
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View shortcut.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/facilis/user/shortcut/edit" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "page": 64,
    "limit": 2115
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/facilis/user/shortcut/edit',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'page' => 64,
            'limit' => 2115.0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/facilis/user/shortcut/edit"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "page": 64,
    "limit": 2115
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Update shortcut.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/aut/user/shortcut/manage/21" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sort_type": "et"
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/aut/user/shortcut/manage/21',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sort_type' => 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/user/shortcut/manage/21"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sort_type": "et"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View minimized user information.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/laudantium/user/simple/illum" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/laudantium/user/simple/illum',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/laudantium/user/simple/illum"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/user/validate/identity

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/voluptas/user/validate/identity" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "email": "[email protected]",
    "phone_number": "ad",
    "user_name": "sint",
    "check_exist": 153625.38136048
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/voluptas/user/validate/identity',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'email' => '[email protected]',
            'phone_number' => 'ad',
            'user_name' => 'sint',
            'check_exist' => 153625.38136048,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/voluptas/user/validate/identity"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "[email protected]",
    "phone_number": "ad",
    "user_name": "sint",
    "check_exist": 153625.38136048
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/user/validate/identity

URL Parameters

ver string

Body Parameters

email string optional

This field is required when none of user_name and phone_number are present. Must be a valid email address.

phone_number string optional

This field is required when none of user_name and email are present.

user_name string optional

This field is required when none of email and phone_number are present.

check_exist number optional

POST api/{ver}/user/validate/phone-number

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/soluta/user/validate/phone-number" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "phone_number": "necessitatibus"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/soluta/user/validate/phone-number',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'phone_number' => 'necessitatibus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/soluta/user/validate/phone-number"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "phone_number": "necessitatibus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/user/verify

Example request:

curl --request POST \
    "http://localhost/api/v1/api/dolorem/user/verify" \
    --header "Content-Type: application/json" \
    --data "{
    "action": "quo",
    "verification_code": "909241"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/dolorem/user/verify',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'action' => 'quo',
            'verification_code' => '909241',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolorem/user/verify"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "action": "quo",
    "verification_code": "909241"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/user/verify/form

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aspernatur/user/verify/form" \
    --header "Content-Type: application/json" \
    --data "{
    "action": "beatae",
    "user_id": 170220577.57,
    "email": "[email protected]",
    "phone_number": "consequatur",
    "resolution": "ea"
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aspernatur/user/verify/form',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'action' => 'beatae',
            'user_id' => 170220577.57,
            'email' => '[email protected]',
            'phone_number' => 'consequatur',
            'resolution' => 'ea',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aspernatur/user/verify/form"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "action": "beatae",
    "user_id": 170220577.57,
    "email": "[email protected]",
    "phone_number": "consequatur",
    "resolution": "ea"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/user/verify/form

URL Parameters

ver string

Body Parameters

action string

user_id number

email string optional

This field is required when phone_number is not present. Must be a valid email address.

phone_number string optional

This field is required when email is not present.

resolution string optional

POST api/{ver}/user/verify/resend

Example request:

curl --request POST \
    "http://localhost/api/v1/api/sapiente/user/verify/resend" \
    --header "Content-Type: application/json" \
    --data "{
    "action": "voluptas",
    "user_id": 2525703.8337563,
    "email": "[email protected]",
    "phone_number": "asperiores"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/sapiente/user/verify/resend',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'action' => 'voluptas',
            'user_id' => 2525703.8337563,
            'email' => '[email protected]',
            'phone_number' => 'asperiores',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sapiente/user/verify/resend"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "action": "voluptas",
    "user_id": 2525703.8337563,
    "email": "[email protected]",
    "phone_number": "asperiores"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/user/verify/resend

URL Parameters

ver string

Body Parameters

action string

user_id number

email string optional

This field is required when phone_number is not present. Must be a valid email address.

phone_number string optional

This field is required when email is not present.

POST api/{ver}/user/verify/resendLink

Example request:

curl --request POST \
    "http://localhost/api/v1/api/asperiores/user/verify/resendLink" \
    --header "Content-Type: application/json" \
    --data "{
    "email": "[email protected]",
    "phone_number": "dolore"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/asperiores/user/verify/resendLink',
    [
        'headers' => [
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'email' => '[email protected]',
            'phone_number' => 'dolore',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/asperiores/user/verify/resendLink"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "[email protected]",
    "phone_number": "dolore"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/user/verify/{hash}

Example request:

curl --request POST \
    "http://localhost/api/v1/api/et/user/verify/sint"

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost/api/v1/api/et/user/verify/sint');
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/et/user/verify/sint"
);

fetch(url, {
    method: "POST",
}).then(response => response.json());

Received response:

Request failed with error:

GET api/{ver}/user/{id}/item-stats

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/quisquam/user/143/item-stats" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "item_type": "mollitia",
    "item_id": 1.83662555
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/quisquam/user/143/item-stats',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'item_type' => 'mollitia',
            'item_id' => 1.83662555,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/quisquam/user/143/item-stats"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "item_type": "mollitia",
    "item_id": 1.83662555
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View user.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sed/user/8980" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sed/user/8980',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sed/user/8980"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Video

App name: Video Version: 5.0.21 Author: phpFox Updated at: Aug 02, 2024

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/sed/video" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "q": "ab",
    "view": "laudantium",
    "sort": "corrupti",
    "sort_type": "tenetur",
    "when": "omnis",
    "category_id": 1161,
    "owner_id": 14,
    "user_id": 1.0676,
    "page": 61,
    "limit": 6774.3406,
    "is_featured": 17545994.744
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/sed/video',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'q' => 'ab',
            'view' => 'laudantium',
            'sort' => 'corrupti',
            'sort_type' => 'tenetur',
            'when' => 'omnis',
            'category_id' => 1161.0,
            'owner_id' => 14,
            'user_id' => 1.0676,
            'page' => 61,
            'limit' => 6774.3406,
            'is_featured' => 17545994.744,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sed/video"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "q": "ab",
    "view": "laudantium",
    "sort": "corrupti",
    "sort_type": "tenetur",
    "when": "omnis",
    "category_id": 1161,
    "owner_id": 14,
    "user_id": 1.0676,
    "page": 61,
    "limit": 6774.3406,
    "is_featured": 17545994.744
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/video

URL Parameters

ver string

Body Parameters

q string optional

view string optional

sort string optional

sort_type string optional

when string optional

category_id number optional

owner_id integer optional

user_id number optional

page number optional

Must be at least 1.

limit number optional

is_featured number optional

Create a resource.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/cupiditate/video" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "reprehenderit",
    "text": "molestiae",
    "thumbnail": {
        "temp_file": 404.80323125
    },
    "video_url": "http:\/\/www.herzog.com\/quaerat-inventore-aperiam-ut-sit",
    "categories": [
        21
    ],
    "owner_id": 153141546.8,
    "privacy": "corrupti",
    "is_posted_from_feed": 1514.79
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/cupiditate/video',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'reprehenderit',
            'text' => 'molestiae',
            'thumbnail' => [
                'temp_file' => 404.80323125,
            ],
            'video_url' => 'http://www.herzog.com/quaerat-inventore-aperiam-ut-sit',
            'categories' => [
                21.0,
            ],
            'owner_id' => 153141546.8,
            'privacy' => 'corrupti',
            'is_posted_from_feed' => 1514.79,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/cupiditate/video"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "reprehenderit",
    "text": "molestiae",
    "thumbnail": {
        "temp_file": 404.80323125
    },
    "video_url": "http:\/\/www.herzog.com\/quaerat-inventore-aperiam-ut-sit",
    "categories": [
        21
    ],
    "owner_id": 153141546.8,
    "privacy": "corrupti",
    "is_posted_from_feed": 1514.79
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/video

URL Parameters

ver string

Body Parameters

title string

text string optional

file string optional

This field is required when video_url is not present.

file.temp_file number optional

This field is required when file is present.

thumbnail object optional

thumbnail.temp_file number optional

This field is required when thumbnail is present.

video_url string optional

This field is required when file is not present. Must be a valid URL.

categories number[] optional

owner_id number optional

privacy string

is_posted_from_feed number optional

PATCH api/{ver}/video/approve/{id}

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/qui/video/approve/857" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/qui/video/approve/857',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/qui/video/approve/857"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

POST api/{ver}/video/callback/{provider}

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/blanditiis/video/callback/vitae" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/blanditiis/video/callback/vitae',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/blanditiis/video/callback/vitae"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/fuga/video/category" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "id": 186928.757,
    "page": 12,
    "q": "et",
    "level": 39.1,
    "limit": 46
}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/fuga/video/category',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'id' => 186928.757,
            'page' => 12,
            'q' => 'et',
            'level' => 39.1,
            'limit' => 46,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/fuga/video/category"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": 186928.757,
    "page": 12,
    "q": "et",
    "level": 39.1,
    "limit": 46
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

GET api/{ver}/video/category

URL Parameters

ver string

Body Parameters

id number optional

page number optional

Must be at least 1.

q string optional

level number optional

limit number optional

Must be at least 10.

Store a newly created resource in storage.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/sed/video/category" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "name": [],
    "name_url": "http:\/\/www.stracke.com\/dolorem-itaque-facere-nam",
    "is_active": 1,
    "ordering": 87,
    "parent_id": 32.541
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/sed/video/category',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => [],
            'name_url' => 'http://www.stracke.com/dolorem-itaque-facere-nam',
            'is_active' => 1,
            'ordering' => 87,
            'parent_id' => 32.541,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sed/video/category"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": [],
    "name_url": "http:\/\/www.stracke.com\/dolorem-itaque-facere-nam",
    "is_active": 1,
    "ordering": 87,
    "parent_id": 32.541
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

POST api/{ver}/video/category

URL Parameters

ver string

Body Parameters

name object

name_url string optional

Must be between 3 and 255 characters.

is_active number optional

Must be between 0 and 1.

ordering number optional

Must be at least 0.

parent_id number optional

Display the specified resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/aut/video/category/06979" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/aut/video/category/06979',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/video/category/06979"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

PATCH api/{ver}/video/feature/{id}

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/dolores/video/feature/468222" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "feature": "0"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/dolores/video/feature/468222',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'feature' => '0',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolores/video/feature/468222"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "feature": "0"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

View link.

requires authentication

Example request:

curl --request POST \
    "http://localhost/api/v1/api/sit/video/fetch" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "link": "http:\/\/prosacco.com\/excepturi-voluptate-aut-quo-cum-maxime-explicabo-ex.html"
}"

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://localhost/api/v1/api/sit/video/fetch',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'link' => 'http://prosacco.com/excepturi-voluptate-aut-quo-cum-maxime-explicabo-ex.html',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/sit/video/fetch"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "link": "http:\/\/prosacco.com\/excepturi-voluptate-aut-quo-cum-maxime-explicabo-ex.html"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/ut/video/sponsor-in-feed/60" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": 3.86
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/ut/video/sponsor-in-feed/60',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 3.86,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/ut/video/sponsor-in-feed/60"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": 3.86
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

requires authentication

Example request:

curl --request PATCH \
    "http://localhost/api/v1/api/distinctio/video/sponsor/8704" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "sponsor": "accusantium"
}"

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://localhost/api/v1/api/distinctio/video/sponsor/8704',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'sponsor' => 'accusantium',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/distinctio/video/sponsor/8704"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sponsor": "accusantium"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Display the specified resource.

requires authentication

Example request:

curl --request GET \
    --get "http://localhost/api/v1/api/dolorem/video/27" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://localhost/api/v1/api/dolorem/video/27',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/dolorem/video/27"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Update a resource.

requires authentication

Example request:

curl --request PUT \
    "http://localhost/api/v1/api/similique/video/84" \
    --header "Authorization: Bearer {accessToken}" \
    --header "Content-Type: application/json" \
    --data "{
    "title": "quos",
    "text": "deleniti",
    "thumbnail": {
        "temp_file": 1014.608563196,
        "status": "dicta"
    },
    "categories": [
        4684.7549
    ],
    "owner_id": 2464.782044,
    "privacy": "debitis"
}"

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://localhost/api/v1/api/similique/video/84',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'title' => 'quos',
            'text' => 'deleniti',
            'thumbnail' => [
                'temp_file' => 1014.608563196,
                'status' => 'dicta',
            ],
            'categories' => [
                4684.7549,
            ],
            'owner_id' => 2464.782044,
            'privacy' => 'debitis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/similique/video/84"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "quos",
    "text": "deleniti",
    "thumbnail": {
        "temp_file": 1014.608563196,
        "status": "dicta"
    },
    "categories": [
        4684.7549
    ],
    "owner_id": 2464.782044,
    "privacy": "debitis"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

Received response:

Request failed with error:

Request

PUT api/{ver}/video/{id}

PATCH api/{ver}/video/{id}

URL Parameters

ver string

id string

The ID of the video.

Body Parameters

title string optional

text string optional

thumbnail object optional

thumbnail.temp_file number optional

This field is required when file.status is update.

thumbnail.status string optional

This field is required when file is present.

categories number[] optional

owner_id number optional

privacy string

Delete a resource.

requires authentication

Example request:

curl --request DELETE \
    "http://localhost/api/v1/api/aut/video/0" \
    --header "Authorization: Bearer {accessToken}"

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://localhost/api/v1/api/aut/video/0',
    [
        'headers' => [
            'Authorization' => 'Bearer {accessToken}',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

const url = new URL(
    "http://localhost/api/v1/api/aut/video/0"
);

const headers = {
    "Authorization": "Bearer {accessToken}",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

Received response:

Request failed with error:

Introduction

Authenticating requests

Activity Point

Browse item

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

GET api/{ver}/activitypoint/conversion-request/{id}

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

PATCH api/{ver}/activitypoint/conversion-request/{id}/cancel

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Browse item.

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Query Parameters

Body Parameters

Browse item.

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

POST api/{ver}/activitypoint/package/purchase/{id}

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

View item.

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Browse item.

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

View item.

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Browse item.

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

View item.

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Advertise

GET api/{ver}/advertise/advertise

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

POST api/{ver}/advertise/advertise

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

PATCH api/{ver}/advertise/advertise/active/{id}

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

PATCH api/{ver}/advertise/advertise/hide/{id}

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

GET api/{ver}/advertise/advertise/report/{id}

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

GET api/{ver}/advertise/advertise/show

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

PATCH api/{ver}/advertise/advertise/total/{id}

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

View item.

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

PUT api/{ver}/advertise/advertise/{id}

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

Delete item.

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request