{
    "info": {
        "_postman_id": "9251e558-5bdd-4f7c-842d-f03341c9b899",
        "name": "Guper · Connect",
        "description": "Guper Connect API reference. Generated from the documentation portal.",
        "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
    },
    "item": [
        {
            "name": "API",
            "item": [
                {
                    "name": "Create Access",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/access",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "access"
                            ]
                        },
                        "description": "Registers a new **API access** entry for the organization — an `(apiKey, apiSecret)`\npair that integrations later exchange for a session token at\n[Get token](/docs/{lang}/api-reference/connect/api/get-token).\n\nThe `apiSecret` is hashed before persistence, so the plaintext is only ever\nseen on this request — store it on your side immediately.",
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"identification\": \"Admin\",\n    \"apiKey\": \"acme\",\n    \"apiSecret\": \"a10b20c30\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    },
                    "response": [
                        {
                            "name": "Access created",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/access",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "access"
                                    ]
                                },
                                "description": "Registers a new **API access** entry for the organization — an `(apiKey, apiSecret)`\npair that integrations later exchange for a session token at\n[Get token](/docs/{lang}/api-reference/connect/api/get-token).\n\nThe `apiSecret` is hashed before persistence, so the plaintext is only ever\nseen on this request — store it on your side immediately.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"identification\": \"Admin\",\n    \"apiKey\": \"acme\",\n    \"apiSecret\": \"a10b20c30\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"account\":        \"acme\",\n    \"identification\": \"Admin\",\n    \"apiKey\":         \"acme\",\n    \"apiSecret\":      \"**************\",\n    \"dateTime\":       \"2026-05-04T13:38:24-03:00\"\n}"
                        },
                        {
                            "name": "Body missing fields or apiKey already exists",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/access",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "access"
                                    ]
                                },
                                "description": "Registers a new **API access** entry for the organization — an `(apiKey, apiSecret)`\npair that integrations later exchange for a session token at\n[Get token](/docs/{lang}/api-reference/connect/api/get-token).\n\nThe `apiSecret` is hashed before persistence, so the plaintext is only ever\nseen on this request — store it on your side immediately.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"identification\": \"Admin\",\n    \"apiKey\": \"acme\",\n    \"apiSecret\": \"a10b20c30\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Bad Request",
                            "code": 400,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{ \"error\": \"duplicate\", \"message\": \"Access to acme has already been created - code: E0018\" }"
                        }
                    ]
                },
                {
                    "name": "Get token",
                    "request": {
                        "method": "GET",
                        "header": [
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            },
                            {
                                "key": "x-guper-apikey",
                                "value": "{{x-guper-apikey}}",
                                "type": "text",
                                "description": "Public identifier of your integration account (issued by Guper)."
                            },
                            {
                                "key": "x-guper-apisecret",
                                "value": "{{x-guper-apisecret}}",
                                "type": "text",
                                "description": "Secret value of your integration account. Treat as a password — never expose to the browser."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/token",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "token"
                            ]
                        },
                        "description": "Issues a new access token for an integration. Uses the **API Key + API Secret**\npair issued during account setup — *not* the user `x-guper-authorization`\ntoken (this endpoint is what produces it). The returned `accessToken` is\nsent on every subsequent request as `x-guper-authorization`.\n\n**Mind `expiresIn`.** A token presented after that moment is refused with\n`401` and `Code: E0002` by every endpoint that takes\n`x-guper-authorization` — call this endpoint again to get a fresh one.\nAsking for a new token before the current one expires is fine and does not\nrevoke it.\n\nWrong credentials answer `401`. After **8 failed attempts for the same\nkey and origin IP** this endpoint answers `429` for **15 minutes**; other\ncallers of the same organization are not affected."
                    },
                    "response": [
                        {
                            "name": "Token issued",
                            "originalRequest": {
                                "method": "GET",
                                "header": [
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    },
                                    {
                                        "key": "x-guper-apikey",
                                        "value": "{{x-guper-apikey}}",
                                        "type": "text",
                                        "description": "Public identifier of your integration account (issued by Guper)."
                                    },
                                    {
                                        "key": "x-guper-apisecret",
                                        "value": "{{x-guper-apisecret}}",
                                        "type": "text",
                                        "description": "Secret value of your integration account. Treat as a password — never expose to the browser."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/token",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "token"
                                    ]
                                },
                                "description": "Issues a new access token for an integration. Uses the **API Key + API Secret**\npair issued during account setup — *not* the user `x-guper-authorization`\ntoken (this endpoint is what produces it). The returned `accessToken` is\nsent on every subsequent request as `x-guper-authorization`.\n\n**Mind `expiresIn`.** A token presented after that moment is refused with\n`401` and `Code: E0002` by every endpoint that takes\n`x-guper-authorization` — call this endpoint again to get a fresh one.\nAsking for a new token before the current one expires is fine and does not\nrevoke it.\n\nWrong credentials answer `401`. After **8 failed attempts for the same\nkey and origin IP** this endpoint answers `429` for **15 minutes**; other\ncallers of the same organization are not affected."
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"accessToken\": \"c074cb9bd30d7b431230877facb45e0a06790e93dea6a728cef9fdaf656bf349\",\n    \"expiresIn\":   \"2023-08-11T15:13:00-03:00\",\n    \"dateTime\":    \"2023-08-11T09:13:00-03:00\"\n}"
                        },
                        {
                            "name": "Invalid credentials",
                            "originalRequest": {
                                "method": "GET",
                                "header": [
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    },
                                    {
                                        "key": "x-guper-apikey",
                                        "value": "{{x-guper-apikey}}",
                                        "type": "text",
                                        "description": "Public identifier of your integration account (issued by Guper)."
                                    },
                                    {
                                        "key": "x-guper-apisecret",
                                        "value": "{{x-guper-apisecret}}",
                                        "type": "text",
                                        "description": "Secret value of your integration account. Treat as a password — never expose to the browser."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/token",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "token"
                                    ]
                                },
                                "description": "Issues a new access token for an integration. Uses the **API Key + API Secret**\npair issued during account setup — *not* the user `x-guper-authorization`\ntoken (this endpoint is what produces it). The returned `accessToken` is\nsent on every subsequent request as `x-guper-authorization`.\n\n**Mind `expiresIn`.** A token presented after that moment is refused with\n`401` and `Code: E0002` by every endpoint that takes\n`x-guper-authorization` — call this endpoint again to get a fresh one.\nAsking for a new token before the current one expires is fine and does not\nrevoke it.\n\nWrong credentials answer `401`. After **8 failed attempts for the same\nkey and origin IP** this endpoint answers `429` for **15 minutes**; other\ncallers of the same organization are not affected."
                            },
                            "status": "Unauthorized",
                            "code": 401,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"error\":   \"invalid_credentials\",\n    \"message\": \"API key or secret is invalid.\"\n}"
                        },
                        {
                            "name": "Temporarily blocked after 8 failed attempts; try again in 15 minutes",
                            "originalRequest": {
                                "method": "GET",
                                "header": [
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    },
                                    {
                                        "key": "x-guper-apikey",
                                        "value": "{{x-guper-apikey}}",
                                        "type": "text",
                                        "description": "Public identifier of your integration account (issued by Guper)."
                                    },
                                    {
                                        "key": "x-guper-apisecret",
                                        "value": "{{x-guper-apisecret}}",
                                        "type": "text",
                                        "description": "Secret value of your integration account. Treat as a password — never expose to the browser."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/token",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "token"
                                    ]
                                },
                                "description": "Issues a new access token for an integration. Uses the **API Key + API Secret**\npair issued during account setup — *not* the user `x-guper-authorization`\ntoken (this endpoint is what produces it). The returned `accessToken` is\nsent on every subsequent request as `x-guper-authorization`.\n\n**Mind `expiresIn`.** A token presented after that moment is refused with\n`401` and `Code: E0002` by every endpoint that takes\n`x-guper-authorization` — call this endpoint again to get a fresh one.\nAsking for a new token before the current one expires is fine and does not\nrevoke it.\n\nWrong credentials answer `401`. After **8 failed attempts for the same\nkey and origin IP** this endpoint answers `429` for **15 minutes**; other\ncallers of the same organization are not affected."
                            },
                            "status": "OK",
                            "code": 429,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"status_code\":   429,\n    \"reason_phrase\": \"Too Many Requests\",\n    \"message\":       \"Too many failed attempts. Try again later.\"\n}"
                        }
                    ]
                },
                {
                    "name": "Grant Access Scope",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/accessScope",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "accessScope"
                            ]
                        },
                        "description": "Attaches one or more **scopes** to an existing `apiKey`. A scope is the\n`service.scope` pair declared by each Guper service in its account\nconfiguration.\n\nToday every service exposes a single `all` scope — `register.all`,\n`loyalty.all`, `order.all`, `sender.all`, `catalog.all`,\n`organization.all`, `journey.all`, `media-manager.all`,\n`auditObserver.all`, `pipeline.all`, `gapp-be.all` — and `connect`\nexposes six finer ones: `connect.user`, `connect.access`, `connect.scope`,\n`connect.session`, `connect.auth` and `connect.mcp`. Finer scopes for the\nother services are added as the need appears.\n\nA request whose token belongs to a key **without** the scope the route\nrequires is refused with `403` and the response names the missing scope in\n`requiredScope`. Calls signed between Guper services do not go through\nthis check.\n\nSent scopes that don't match a known `service.scope` come back in\n`invalidScopes`; duplicate grants are silently ignored. The response\nalways reflects what was actually persisted.",
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"apiKey\": \"acme\",\n    \"scope\": \"[\\\"register.all\\\", \\\"loyalty.all\\\", \\\"connect.user\\\"]\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    },
                    "response": [
                        {
                            "name": "Scopes granted (with invalidScopes/errors when applicable)",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/accessScope",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "accessScope"
                                    ]
                                },
                                "description": "Attaches one or more **scopes** to an existing `apiKey`. A scope is the\n`service.scope` pair declared by each Guper service in its account\nconfiguration.\n\nToday every service exposes a single `all` scope — `register.all`,\n`loyalty.all`, `order.all`, `sender.all`, `catalog.all`,\n`organization.all`, `journey.all`, `media-manager.all`,\n`auditObserver.all`, `pipeline.all`, `gapp-be.all` — and `connect`\nexposes six finer ones: `connect.user`, `connect.access`, `connect.scope`,\n`connect.session`, `connect.auth` and `connect.mcp`. Finer scopes for the\nother services are added as the need appears.\n\nA request whose token belongs to a key **without** the scope the route\nrequires is refused with `403` and the response names the missing scope in\n`requiredScope`. Calls signed between Guper services do not go through\nthis check.\n\nSent scopes that don't match a known `service.scope` come back in\n`invalidScopes`; duplicate grants are silently ignored. The response\nalways reflects what was actually persisted.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"apiKey\": \"acme\",\n    \"scope\": \"[\\\"register.all\\\", \\\"loyalty.all\\\", \\\"connect.user\\\"]\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"organization\": \"acme\",\n    \"access\":       \"acme\",\n    \"scopes\": [\n        { \"scope\": 1, \"access\": 11 },\n        { \"scope\": 2, \"access\": 11 }\n    ],\n    \"dateTime\":     \"2026-05-04T13:38:53-03:00\"\n}"
                        },
                        {
                            "name": "The calling key lacks the scope the route requires",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/accessScope",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "accessScope"
                                    ]
                                },
                                "description": "Attaches one or more **scopes** to an existing `apiKey`. A scope is the\n`service.scope` pair declared by each Guper service in its account\nconfiguration.\n\nToday every service exposes a single `all` scope — `register.all`,\n`loyalty.all`, `order.all`, `sender.all`, `catalog.all`,\n`organization.all`, `journey.all`, `media-manager.all`,\n`auditObserver.all`, `pipeline.all`, `gapp-be.all` — and `connect`\nexposes six finer ones: `connect.user`, `connect.access`, `connect.scope`,\n`connect.session`, `connect.auth` and `connect.mcp`. Finer scopes for the\nother services are added as the need appears.\n\nA request whose token belongs to a key **without** the scope the route\nrequires is refused with `403` and the response names the missing scope in\n`requiredScope`. Calls signed between Guper services do not go through\nthis check.\n\nSent scopes that don't match a known `service.scope` come back in\n`invalidScopes`; duplicate grants are silently ignored. The response\nalways reflects what was actually persisted.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"apiKey\": \"acme\",\n    \"scope\": \"[\\\"register.all\\\", \\\"loyalty.all\\\", \\\"connect.user\\\"]\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Forbidden",
                            "code": 403,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"status_code\":    403,\n    \"reason_phrase\":  \"Forbidden\",\n    \"message\":        \"Scope required\",\n    \"requiredScope\":  \"connect.scope\"\n}"
                        },
                        {
                            "name": "apiKey not registered",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/accessScope",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "accessScope"
                                    ]
                                },
                                "description": "Attaches one or more **scopes** to an existing `apiKey`. A scope is the\n`service.scope` pair declared by each Guper service in its account\nconfiguration.\n\nToday every service exposes a single `all` scope — `register.all`,\n`loyalty.all`, `order.all`, `sender.all`, `catalog.all`,\n`organization.all`, `journey.all`, `media-manager.all`,\n`auditObserver.all`, `pipeline.all`, `gapp-be.all` — and `connect`\nexposes six finer ones: `connect.user`, `connect.access`, `connect.scope`,\n`connect.session`, `connect.auth` and `connect.mcp`. Finer scopes for the\nother services are added as the need appears.\n\nA request whose token belongs to a key **without** the scope the route\nrequires is refused with `403` and the response names the missing scope in\n`requiredScope`. Calls signed between Guper services do not go through\nthis check.\n\nSent scopes that don't match a known `service.scope` come back in\n`invalidScopes`; duplicate grants are silently ignored. The response\nalways reflects what was actually persisted.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"apiKey\": \"acme\",\n    \"scope\": \"[\\\"register.all\\\", \\\"loyalty.all\\\", \\\"connect.user\\\"]\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Not Found",
                            "code": 404,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{ \"error\": \"not_found\", \"message\": \"Access not found for apiKey\" }"
                        }
                    ]
                }
            ]
        },
        {
            "name": "Password Reset",
            "item": [
                {
                    "name": "Confirm Password Reset",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/confirm",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "password-reset",
                                "confirm"
                            ]
                        },
                        "description": "Confirms a password-reset request by consuming the token and setting a new\npassword.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nthe same mechanism used in the request step. The verified `user-agent`\n**must match** the origin that created the reset request — this is the\n**origin lock**. A token issued by `admin` cannot be confirmed by\n`storemanager`, even with a valid signature.\n\n**Token rules:**\n- Single-use — once confirmed, the token is marked `used` and cannot be\n  redeemed again.\n- Expires after **1 hour** from creation.\n- Any pending tokens for the same `(organization, login)` are superseded\n  when a new request is created.\n\n**Password history:** The new password is checked against the user's\n**current password** and their **last 10 password hashes**. If the password\nhas been used before, the request is rejected with HTTP 400.\n\nOn success, the user's password is updated, brute-force login attempt\nrecords are cleared, and the token is marked as used.",
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"token\": \"a1b2c3d4e5f6...64 hex characters\",\n    \"password\": \"NewSecurePass123!\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    },
                    "response": [
                        {
                            "name": "Password changed successfully",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/confirm",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "password-reset",
                                        "confirm"
                                    ]
                                },
                                "description": "Confirms a password-reset request by consuming the token and setting a new\npassword.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nthe same mechanism used in the request step. The verified `user-agent`\n**must match** the origin that created the reset request — this is the\n**origin lock**. A token issued by `admin` cannot be confirmed by\n`storemanager`, even with a valid signature.\n\n**Token rules:**\n- Single-use — once confirmed, the token is marked `used` and cannot be\n  redeemed again.\n- Expires after **1 hour** from creation.\n- Any pending tokens for the same `(organization, login)` are superseded\n  when a new request is created.\n\n**Password history:** The new password is checked against the user's\n**current password** and their **last 10 password hashes**. If the password\nhas been used before, the request is rejected with HTTP 400.\n\nOn success, the user's password is updated, brute-force login attempt\nrecords are cleared, and the token is marked as used.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"token\": \"a1b2c3d4e5f6...64 hex characters\",\n    \"password\": \"NewSecurePass123!\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"success\": true\n}"
                        },
                        {
                            "name": "Invalid or expired token",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/confirm",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "password-reset",
                                        "confirm"
                                    ]
                                },
                                "description": "Confirms a password-reset request by consuming the token and setting a new\npassword.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nthe same mechanism used in the request step. The verified `user-agent`\n**must match** the origin that created the reset request — this is the\n**origin lock**. A token issued by `admin` cannot be confirmed by\n`storemanager`, even with a valid signature.\n\n**Token rules:**\n- Single-use — once confirmed, the token is marked `used` and cannot be\n  redeemed again.\n- Expires after **1 hour** from creation.\n- Any pending tokens for the same `(organization, login)` are superseded\n  when a new request is created.\n\n**Password history:** The new password is checked against the user's\n**current password** and their **last 10 password hashes**. If the password\nhas been used before, the request is rejected with HTTP 400.\n\nOn success, the user's password is updated, brute-force login attempt\nrecords are cleared, and the token is marked as used.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"token\": \"a1b2c3d4e5f6...64 hex characters\",\n    \"password\": \"NewSecurePass123!\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Bad Request",
                            "code": 400,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"status_code\":   400,\n    \"reason_phrase\": \"Invalid or expired token\"\n}"
                        },
                        {
                            "name": "Password too short (minimum 8 characters)",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/confirm",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "password-reset",
                                        "confirm"
                                    ]
                                },
                                "description": "Confirms a password-reset request by consuming the token and setting a new\npassword.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nthe same mechanism used in the request step. The verified `user-agent`\n**must match** the origin that created the reset request — this is the\n**origin lock**. A token issued by `admin` cannot be confirmed by\n`storemanager`, even with a valid signature.\n\n**Token rules:**\n- Single-use — once confirmed, the token is marked `used` and cannot be\n  redeemed again.\n- Expires after **1 hour** from creation.\n- Any pending tokens for the same `(organization, login)` are superseded\n  when a new request is created.\n\n**Password history:** The new password is checked against the user's\n**current password** and their **last 10 password hashes**. If the password\nhas been used before, the request is rejected with HTTP 400.\n\nOn success, the user's password is updated, brute-force login attempt\nrecords are cleared, and the token is marked as used.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"token\": \"a1b2c3d4e5f6...64 hex characters\",\n    \"password\": \"NewSecurePass123!\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Bad Request",
                            "code": 400,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"status_code\":   400,\n    \"reason_phrase\": \"Password must be at least 8 characters\"\n}"
                        },
                        {
                            "name": "Password reused (matches current or one of last 10)",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/confirm",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "password-reset",
                                        "confirm"
                                    ]
                                },
                                "description": "Confirms a password-reset request by consuming the token and setting a new\npassword.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nthe same mechanism used in the request step. The verified `user-agent`\n**must match** the origin that created the reset request — this is the\n**origin lock**. A token issued by `admin` cannot be confirmed by\n`storemanager`, even with a valid signature.\n\n**Token rules:**\n- Single-use — once confirmed, the token is marked `used` and cannot be\n  redeemed again.\n- Expires after **1 hour** from creation.\n- Any pending tokens for the same `(organization, login)` are superseded\n  when a new request is created.\n\n**Password history:** The new password is checked against the user's\n**current password** and their **last 10 password hashes**. If the password\nhas been used before, the request is rejected with HTTP 400.\n\nOn success, the user's password is updated, brute-force login attempt\nrecords are cleared, and the token is marked as used.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"token\": \"a1b2c3d4e5f6...64 hex characters\",\n    \"password\": \"NewSecurePass123!\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Bad Request",
                            "code": 400,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"status_code\":   400,\n    \"reason_phrase\": \"This password has been used before. Please choose a different one\"\n}"
                        },
                        {
                            "name": "Origin mismatch (confirming system differs from requesting system)",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/confirm",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "password-reset",
                                        "confirm"
                                    ]
                                },
                                "description": "Confirms a password-reset request by consuming the token and setting a new\npassword.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nthe same mechanism used in the request step. The verified `user-agent`\n**must match** the origin that created the reset request — this is the\n**origin lock**. A token issued by `admin` cannot be confirmed by\n`storemanager`, even with a valid signature.\n\n**Token rules:**\n- Single-use — once confirmed, the token is marked `used` and cannot be\n  redeemed again.\n- Expires after **1 hour** from creation.\n- Any pending tokens for the same `(organization, login)` are superseded\n  when a new request is created.\n\n**Password history:** The new password is checked against the user's\n**current password** and their **last 10 password hashes**. If the password\nhas been used before, the request is rejected with HTTP 400.\n\nOn success, the user's password is updated, brute-force login attempt\nrecords are cleared, and the token is marked as used.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"token\": \"a1b2c3d4e5f6...64 hex characters\",\n    \"password\": \"NewSecurePass123!\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Forbidden",
                            "code": 403,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"status_code\":   403,\n    \"reason_phrase\": \"Origin mismatch\"\n}"
                        }
                    ]
                },
                {
                    "name": "Request Password Reset",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/request",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "password-reset",
                                "request"
                            ]
                        },
                        "description": "Initiates a password-reset flow for a user in the organization.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nnot a user token — because the user requesting a reset is not logged in.\nThe `user-agent` header identifies the calling system (e.g. `admin`,\n`storemanager`) and is cryptographically verified against its public key\nin `etc/keys/{user-agent}.pem`.\n\nThe verified `user-agent` is stored as the request's **origin**. Only the\nsame origin can later confirm the reset — this is the **origin lock**,\nwhich prevents a token issued by one system from being redeemed by another.\n\n**Anti-enumeration:** When the login does not exist, the endpoint returns\n`{ \"requested\": true }` without `token` or `personId`. The caller cannot\ndistinguish this from a successful request and should always show a generic\n\"check your email\" message to the end user.\n\n**Cooldown:** A 5-minute cooldown is enforced per `(organization, login)`.\nA second request within the window returns HTTP 429.\n\nThe caller is responsible for delivering the token to the user (e-mail,\nWhatsApp, etc.) — Connect generates and validates the token but does not\nsend any notification.",
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"login\": \"maria.silva@company.com\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    },
                    "response": [
                        {
                            "name": "User exists — token generated",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/request",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "password-reset",
                                        "request"
                                    ]
                                },
                                "description": "Initiates a password-reset flow for a user in the organization.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nnot a user token — because the user requesting a reset is not logged in.\nThe `user-agent` header identifies the calling system (e.g. `admin`,\n`storemanager`) and is cryptographically verified against its public key\nin `etc/keys/{user-agent}.pem`.\n\nThe verified `user-agent` is stored as the request's **origin**. Only the\nsame origin can later confirm the reset — this is the **origin lock**,\nwhich prevents a token issued by one system from being redeemed by another.\n\n**Anti-enumeration:** When the login does not exist, the endpoint returns\n`{ \"requested\": true }` without `token` or `personId`. The caller cannot\ndistinguish this from a successful request and should always show a generic\n\"check your email\" message to the end user.\n\n**Cooldown:** A 5-minute cooldown is enforced per `(organization, login)`.\nA second request within the window returns HTTP 429.\n\nThe caller is responsible for delivering the token to the user (e-mail,\nWhatsApp, etc.) — Connect generates and validates the token but does not\nsend any notification.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"login\": \"maria.silva@company.com\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"requested\": true,\n    \"token\":     \"a1b2c3d4e5f6...64 hex characters\",\n    \"personId\":  4399137,\n    \"login\":     \"maria.silva@company.com\"\n}"
                        },
                        {
                            "name": "User does not exist (anti-enumeration — same shape, no token)",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/request",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "password-reset",
                                        "request"
                                    ]
                                },
                                "description": "Initiates a password-reset flow for a user in the organization.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nnot a user token — because the user requesting a reset is not logged in.\nThe `user-agent` header identifies the calling system (e.g. `admin`,\n`storemanager`) and is cryptographically verified against its public key\nin `etc/keys/{user-agent}.pem`.\n\nThe verified `user-agent` is stored as the request's **origin**. Only the\nsame origin can later confirm the reset — this is the **origin lock**,\nwhich prevents a token issued by one system from being redeemed by another.\n\n**Anti-enumeration:** When the login does not exist, the endpoint returns\n`{ \"requested\": true }` without `token` or `personId`. The caller cannot\ndistinguish this from a successful request and should always show a generic\n\"check your email\" message to the end user.\n\n**Cooldown:** A 5-minute cooldown is enforced per `(organization, login)`.\nA second request within the window returns HTTP 429.\n\nThe caller is responsible for delivering the token to the user (e-mail,\nWhatsApp, etc.) — Connect generates and validates the token but does not\nsend any notification.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"login\": \"maria.silva@company.com\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"requested\": true\n}"
                        },
                        {
                            "name": "Cooldown active (less than 5 minutes since last request for this login)",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/request",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "password-reset",
                                        "request"
                                    ]
                                },
                                "description": "Initiates a password-reset flow for a user in the organization.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nnot a user token — because the user requesting a reset is not logged in.\nThe `user-agent` header identifies the calling system (e.g. `admin`,\n`storemanager`) and is cryptographically verified against its public key\nin `etc/keys/{user-agent}.pem`.\n\nThe verified `user-agent` is stored as the request's **origin**. Only the\nsame origin can later confirm the reset — this is the **origin lock**,\nwhich prevents a token issued by one system from being redeemed by another.\n\n**Anti-enumeration:** When the login does not exist, the endpoint returns\n`{ \"requested\": true }` without `token` or `personId`. The caller cannot\ndistinguish this from a successful request and should always show a generic\n\"check your email\" message to the end user.\n\n**Cooldown:** A 5-minute cooldown is enforced per `(organization, login)`.\nA second request within the window returns HTTP 429.\n\nThe caller is responsible for delivering the token to the user (e-mail,\nWhatsApp, etc.) — Connect generates and validates the token but does not\nsend any notification.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"login\": \"maria.silva@company.com\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 429,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"status_code\":   429,\n    \"reason_phrase\": \"Please wait before requesting another reset\"\n}"
                        }
                    ]
                },
                {
                    "name": "Validate Password Reset Token",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/validate",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "password-reset",
                                "validate"
                            ]
                        },
                        "description": "Validates a password-reset token without consuming it.\n\nThis is a **pre-flight check** — the caller uses it to decide what to show\nthe user before they type a new password. The token remains `pending` and\ncan still be confirmed afterwards.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nthe same mechanism used in the request and confirm steps.\n\nThe endpoint checks, in order:\n1. **Existence** — the SHA-256 hash of the raw token must match a row in\n   `password_reset_request`.\n2. **Organization** — the row must belong to the current organization.\n3. **Status** — `used` and `superseded` tokens are rejected with a specific\n   reason so the UI can show an appropriate message.\n4. **Expiration** — tokens older than 1 hour are rejected as `expired`.\n\nIf all checks pass, the response is `{ \"valid\": true }`. Otherwise,\n`{ \"valid\": false, \"reason\": \"...\" }` with one of the reason codes below.\n\n**Reason codes:**\n| Code | Meaning |\n|------|---------|\n| `not_found` | Token does not exist or belongs to another organization |\n| `used` | Token was already consumed by a confirm call |\n| `superseded` | A newer reset was requested for the same login |\n| `expired` | Token is older than 1 hour |",
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"token\": \"a1b2c3d4e5f6...64 hex characters\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    },
                    "response": [
                        {
                            "name": "Token is valid and can be confirmed",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/validate",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "password-reset",
                                        "validate"
                                    ]
                                },
                                "description": "Validates a password-reset token without consuming it.\n\nThis is a **pre-flight check** — the caller uses it to decide what to show\nthe user before they type a new password. The token remains `pending` and\ncan still be confirmed afterwards.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nthe same mechanism used in the request and confirm steps.\n\nThe endpoint checks, in order:\n1. **Existence** — the SHA-256 hash of the raw token must match a row in\n   `password_reset_request`.\n2. **Organization** — the row must belong to the current organization.\n3. **Status** — `used` and `superseded` tokens are rejected with a specific\n   reason so the UI can show an appropriate message.\n4. **Expiration** — tokens older than 1 hour are rejected as `expired`.\n\nIf all checks pass, the response is `{ \"valid\": true }`. Otherwise,\n`{ \"valid\": false, \"reason\": \"...\" }` with one of the reason codes below.\n\n**Reason codes:**\n| Code | Meaning |\n|------|---------|\n| `not_found` | Token does not exist or belongs to another organization |\n| `used` | Token was already consumed by a confirm call |\n| `superseded` | A newer reset was requested for the same login |\n| `expired` | Token is older than 1 hour |",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"token\": \"a1b2c3d4e5f6...64 hex characters\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"valid\": true\n}"
                        },
                        {
                            "name": "Token not found or belongs to another organization",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/validate",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "password-reset",
                                        "validate"
                                    ]
                                },
                                "description": "Validates a password-reset token without consuming it.\n\nThis is a **pre-flight check** — the caller uses it to decide what to show\nthe user before they type a new password. The token remains `pending` and\ncan still be confirmed afterwards.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nthe same mechanism used in the request and confirm steps.\n\nThe endpoint checks, in order:\n1. **Existence** — the SHA-256 hash of the raw token must match a row in\n   `password_reset_request`.\n2. **Organization** — the row must belong to the current organization.\n3. **Status** — `used` and `superseded` tokens are rejected with a specific\n   reason so the UI can show an appropriate message.\n4. **Expiration** — tokens older than 1 hour are rejected as `expired`.\n\nIf all checks pass, the response is `{ \"valid\": true }`. Otherwise,\n`{ \"valid\": false, \"reason\": \"...\" }` with one of the reason codes below.\n\n**Reason codes:**\n| Code | Meaning |\n|------|---------|\n| `not_found` | Token does not exist or belongs to another organization |\n| `used` | Token was already consumed by a confirm call |\n| `superseded` | A newer reset was requested for the same login |\n| `expired` | Token is older than 1 hour |",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"token\": \"a1b2c3d4e5f6...64 hex characters\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"valid\":  false,\n    \"reason\": \"not_found\"\n}"
                        },
                        {
                            "name": "Token already used",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/validate",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "password-reset",
                                        "validate"
                                    ]
                                },
                                "description": "Validates a password-reset token without consuming it.\n\nThis is a **pre-flight check** — the caller uses it to decide what to show\nthe user before they type a new password. The token remains `pending` and\ncan still be confirmed afterwards.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nthe same mechanism used in the request and confirm steps.\n\nThe endpoint checks, in order:\n1. **Existence** — the SHA-256 hash of the raw token must match a row in\n   `password_reset_request`.\n2. **Organization** — the row must belong to the current organization.\n3. **Status** — `used` and `superseded` tokens are rejected with a specific\n   reason so the UI can show an appropriate message.\n4. **Expiration** — tokens older than 1 hour are rejected as `expired`.\n\nIf all checks pass, the response is `{ \"valid\": true }`. Otherwise,\n`{ \"valid\": false, \"reason\": \"...\" }` with one of the reason codes below.\n\n**Reason codes:**\n| Code | Meaning |\n|------|---------|\n| `not_found` | Token does not exist or belongs to another organization |\n| `used` | Token was already consumed by a confirm call |\n| `superseded` | A newer reset was requested for the same login |\n| `expired` | Token is older than 1 hour |",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"token\": \"a1b2c3d4e5f6...64 hex characters\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"valid\":  false,\n    \"reason\": \"used\"\n}"
                        },
                        {
                            "name": "Token superseded by a newer request",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/validate",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "password-reset",
                                        "validate"
                                    ]
                                },
                                "description": "Validates a password-reset token without consuming it.\n\nThis is a **pre-flight check** — the caller uses it to decide what to show\nthe user before they type a new password. The token remains `pending` and\ncan still be confirmed afterwards.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nthe same mechanism used in the request and confirm steps.\n\nThe endpoint checks, in order:\n1. **Existence** — the SHA-256 hash of the raw token must match a row in\n   `password_reset_request`.\n2. **Organization** — the row must belong to the current organization.\n3. **Status** — `used` and `superseded` tokens are rejected with a specific\n   reason so the UI can show an appropriate message.\n4. **Expiration** — tokens older than 1 hour are rejected as `expired`.\n\nIf all checks pass, the response is `{ \"valid\": true }`. Otherwise,\n`{ \"valid\": false, \"reason\": \"...\" }` with one of the reason codes below.\n\n**Reason codes:**\n| Code | Meaning |\n|------|---------|\n| `not_found` | Token does not exist or belongs to another organization |\n| `used` | Token was already consumed by a confirm call |\n| `superseded` | A newer reset was requested for the same login |\n| `expired` | Token is older than 1 hour |",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"token\": \"a1b2c3d4e5f6...64 hex characters\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"valid\":  false,\n    \"reason\": \"superseded\"\n}"
                        },
                        {
                            "name": "Token expired (older than 1 hour)",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/password-reset/validate",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "password-reset",
                                        "validate"
                                    ]
                                },
                                "description": "Validates a password-reset token without consuming it.\n\nThis is a **pre-flight check** — the caller uses it to decide what to show\nthe user before they type a new password. The token remains `pending` and\ncan still be confirmed afterwards.\n\nThe caller authenticates via **RSA signature** (OriginValidation middleware),\nthe same mechanism used in the request and confirm steps.\n\nThe endpoint checks, in order:\n1. **Existence** — the SHA-256 hash of the raw token must match a row in\n   `password_reset_request`.\n2. **Organization** — the row must belong to the current organization.\n3. **Status** — `used` and `superseded` tokens are rejected with a specific\n   reason so the UI can show an appropriate message.\n4. **Expiration** — tokens older than 1 hour are rejected as `expired`.\n\nIf all checks pass, the response is `{ \"valid\": true }`. Otherwise,\n`{ \"valid\": false, \"reason\": \"...\" }` with one of the reason codes below.\n\n**Reason codes:**\n| Code | Meaning |\n|------|---------|\n| `not_found` | Token does not exist or belongs to another organization |\n| `used` | Token was already consumed by a confirm call |\n| `superseded` | A newer reset was requested for the same login |\n| `expired` | Token is older than 1 hour |",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"token\": \"a1b2c3d4e5f6...64 hex characters\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"valid\":  false,\n    \"reason\": \"expired\"\n}"
                        }
                    ]
                }
            ]
        },
        {
            "name": "Ping",
            "request": {
                "method": "GET",
                "header": [
                    {
                        "key": "x-guper-authorization",
                        "value": "{{x-guper-authorization}}",
                        "type": "text",
                        "description": "User token issued by Guper."
                    },
                    {
                        "key": "Content-Type",
                        "value": "{{Content-Type}}",
                        "type": "text",
                        "description": "Always `application/json` for endpoints that accept a JSON body."
                    }
                ],
                "url": {
                    "raw": "https://{{organization}}.myguper.com/api/connect/ping",
                    "protocol": "https",
                    "host": [
                        "{{organization}}",
                        "myguper",
                        "com"
                    ],
                    "path": [
                        "api",
                        "connect",
                        "ping"
                    ]
                },
                "description": "Resource for checking service availability"
            },
            "response": [
                {
                    "name": "Successful Response",
                    "originalRequest": {
                        "method": "GET",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/ping",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "ping"
                            ]
                        },
                        "description": "Resource for checking service availability"
                    },
                    "status": "OK",
                    "code": 200,
                    "_postman_previewlanguage": "json",
                    "header": [
                        {
                            "key": "Content-Type",
                            "value": "application/json"
                        }
                    ],
                    "body": "{\n    \"account\": \"acme\",\n    \"response\": \"Server online\",\n    \"dateTime\": \"2023-08-09T22:45:08-03:00\"\n}"
                }
            ]
        },
        {
            "name": "Proof of Work",
            "item": [
                {
                    "name": "Generate challenge — Private",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/pow/challenge",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "pow",
                                "challenge"
                            ]
                        },
                        "description": "Called by internal services (Admin panel, other microservices) using RSA signature authentication.",
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"login\": \"maria.silva\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    },
                    "response": [
                        {
                            "name": "Challenge generated successfully.",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/pow/challenge",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "pow",
                                        "challenge"
                                    ]
                                },
                                "description": "Called by internal services (Admin panel, other microservices) using RSA signature authentication.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"login\": \"maria.silva\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"challenge\": \"a1b2c3d4e5f6...64 hex characters\",\n    \"target\": \"0000ffffffffffff...64 hex characters\"\n}"
                        },
                        {
                            "name": "Missing required field.",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/pow/challenge",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "pow",
                                        "challenge"
                                    ]
                                },
                                "description": "Called by internal services (Admin panel, other microservices) using RSA signature authentication.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"login\": \"maria.silva\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Bad Request",
                            "code": 400,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"error\": \"Missing required field: login\"\n}"
                        }
                    ]
                }
            ]
        },
        {
            "name": "User",
            "item": [
                {
                    "name": "Auth",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/auth",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "auth"
                            ]
                        },
                        "description": "Authenticates a user by `login` + `password` and returns the matching\nperson identity (`personId`, `type`).\n\nOptionally accepts a Proof of Work `challenge` and `nonce` obtained from the\n[Generate challenge](/docs/{lang}/api-reference/connect/pow/challenge) endpoint.\nWhen provided, the server validates that SHA-256(challenge + nonce) <= target before\nchecking credentials. This prevents brute-force attacks by requiring computational\nwork before each login attempt.\n\n**Important:** The `challenge` and `nonce` fields are currently optional for\nbackward compatibility. They will become **required** in a future release.\nAll clients should integrate the Proof of Work flow as soon as possible.\n\nWrong credentials always answer the same `401` — the response never says\nwhether the login exists. After **8 failed attempts for the same login**\nthe endpoint answers `429` and stops checking the password for\n**15 minutes**; a successful sign-in clears the counter.",
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"login\": \"tintin\",\n    \"password\": \"a10b20c30\",\n    \"challenge\": \"a1b2c3d4...64 hex chars\",\n    \"nonce\": \"48293\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    },
                    "response": [
                        {
                            "name": "Successful Response",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/auth",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "auth"
                                    ]
                                },
                                "description": "Authenticates a user by `login` + `password` and returns the matching\nperson identity (`personId`, `type`).\n\nOptionally accepts a Proof of Work `challenge` and `nonce` obtained from the\n[Generate challenge](/docs/{lang}/api-reference/connect/pow/challenge) endpoint.\nWhen provided, the server validates that SHA-256(challenge + nonce) <= target before\nchecking credentials. This prevents brute-force attacks by requiring computational\nwork before each login attempt.\n\n**Important:** The `challenge` and `nonce` fields are currently optional for\nbackward compatibility. They will become **required** in a future release.\nAll clients should integrate the Proof of Work flow as soon as possible.\n\nWrong credentials always answer the same `401` — the response never says\nwhether the login exists. After **8 failed attempts for the same login**\nthe endpoint answers `429` and stops checking the password for\n**15 minutes**; a successful sign-in clears the counter.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"login\": \"tintin\",\n    \"password\": \"a10b20c30\",\n    \"challenge\": \"a1b2c3d4...64 hex chars\",\n    \"nonce\": \"48293\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"personId\": 44,\n    \"type\": \"user\",\n    \"dateTime\": \"2023-08-24T17:13:52-03:00\"\n}"
                        },
                        {
                            "name": "Proof of Work invalid or expired.",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/auth",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "auth"
                                    ]
                                },
                                "description": "Authenticates a user by `login` + `password` and returns the matching\nperson identity (`personId`, `type`).\n\nOptionally accepts a Proof of Work `challenge` and `nonce` obtained from the\n[Generate challenge](/docs/{lang}/api-reference/connect/pow/challenge) endpoint.\nWhen provided, the server validates that SHA-256(challenge + nonce) <= target before\nchecking credentials. This prevents brute-force attacks by requiring computational\nwork before each login attempt.\n\n**Important:** The `challenge` and `nonce` fields are currently optional for\nbackward compatibility. They will become **required** in a future release.\nAll clients should integrate the Proof of Work flow as soon as possible.\n\nWrong credentials always answer the same `401` — the response never says\nwhether the login exists. After **8 failed attempts for the same login**\nthe endpoint answers `429` and stops checking the password for\n**15 minutes**; a successful sign-in clears the counter.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"login\": \"tintin\",\n    \"password\": \"a10b20c30\",\n    \"challenge\": \"a1b2c3d4...64 hex chars\",\n    \"nonce\": \"48293\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Bad Request",
                            "code": 400,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"error\": \"Challenge invalid or expired\"\n}"
                        },
                        {
                            "name": "Login or password invalid (same answer for both)",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/auth",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "auth"
                                    ]
                                },
                                "description": "Authenticates a user by `login` + `password` and returns the matching\nperson identity (`personId`, `type`).\n\nOptionally accepts a Proof of Work `challenge` and `nonce` obtained from the\n[Generate challenge](/docs/{lang}/api-reference/connect/pow/challenge) endpoint.\nWhen provided, the server validates that SHA-256(challenge + nonce) <= target before\nchecking credentials. This prevents brute-force attacks by requiring computational\nwork before each login attempt.\n\n**Important:** The `challenge` and `nonce` fields are currently optional for\nbackward compatibility. They will become **required** in a future release.\nAll clients should integrate the Proof of Work flow as soon as possible.\n\nWrong credentials always answer the same `401` — the response never says\nwhether the login exists. After **8 failed attempts for the same login**\nthe endpoint answers `429` and stops checking the password for\n**15 minutes**; a successful sign-in clears the counter.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"login\": \"tintin\",\n    \"password\": \"a10b20c30\",\n    \"challenge\": \"a1b2c3d4...64 hex chars\",\n    \"nonce\": \"48293\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Unauthorized",
                            "code": 401,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"status_code\":   401,\n    \"reason_phrase\": \"Unauthorized\",\n    \"message\":       \"Auth unauthorized\"\n}"
                        },
                        {
                            "name": "Temporarily blocked after 8 failed attempts; try again in 15 minutes",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/auth",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "auth"
                                    ]
                                },
                                "description": "Authenticates a user by `login` + `password` and returns the matching\nperson identity (`personId`, `type`).\n\nOptionally accepts a Proof of Work `challenge` and `nonce` obtained from the\n[Generate challenge](/docs/{lang}/api-reference/connect/pow/challenge) endpoint.\nWhen provided, the server validates that SHA-256(challenge + nonce) <= target before\nchecking credentials. This prevents brute-force attacks by requiring computational\nwork before each login attempt.\n\n**Important:** The `challenge` and `nonce` fields are currently optional for\nbackward compatibility. They will become **required** in a future release.\nAll clients should integrate the Proof of Work flow as soon as possible.\n\nWrong credentials always answer the same `401` — the response never says\nwhether the login exists. After **8 failed attempts for the same login**\nthe endpoint answers `429` and stops checking the password for\n**15 minutes**; a successful sign-in clears the counter.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"login\": \"tintin\",\n    \"password\": \"a10b20c30\",\n    \"challenge\": \"a1b2c3d4...64 hex chars\",\n    \"nonce\": \"48293\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 429,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"status_code\":   429,\n    \"reason_phrase\": \"Too Many Requests\",\n    \"message\":       \"Too many failed attempts. Try again later.\"\n}"
                        }
                    ]
                },
                {
                    "name": "Check Login Exists",
                    "request": {
                        "method": "GET",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/user/by-login",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "user",
                                "by-login"
                            ]
                        },
                        "description": "Checks whether a login (e-mail) already exists for the organization. Strict match on (organization, login) — the unique key of a connect user, without the dev fallback. Used to validate user creation before creating the person, avoiding an orphan person when the e-mail is already in use as a login."
                    },
                    "response": [
                        {
                            "name": "OK. `exists` is true when a user with this login already exists in the organization; `personId` is the owner of the login (null when it does not exist).",
                            "originalRequest": {
                                "method": "GET",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/user/by-login",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "user",
                                        "by-login"
                                    ]
                                },
                                "description": "Checks whether a login (e-mail) already exists for the organization. Strict match on (organization, login) — the unique key of a connect user, without the dev fallback. Used to validate user creation before creating the person, avoiding an orphan person when the e-mail is already in use as a login."
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"login\": \"maria.silva@example.com\",\n    \"exists\": true,\n    \"personId\": 44\n}"
                        },
                        {
                            "name": "Bad Request. The `login` query parameter is missing.",
                            "originalRequest": {
                                "method": "GET",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/user/by-login",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "user",
                                        "by-login"
                                    ]
                                },
                                "description": "Checks whether a login (e-mail) already exists for the organization. Strict match on (organization, login) — the unique key of a connect user, without the dev fallback. Used to validate user creation before creating the person, avoiding an orphan person when the e-mail is already in use as a login."
                            },
                            "status": "Bad Request",
                            "code": 400,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"status_code\": 400,\n    \"reason_phrase\": \"The 'login' parameter is required\"\n}"
                        }
                    ]
                },
                {
                    "name": "Create User",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/user",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "user"
                            ]
                        },
                        "description": "Wires Connect login credentials (`login` + `password`) to an existing\nperson registered in Register.\n\nThis is the **second step** of the user-onboarding flow. The first step is to\nissue an invite token for that person at\n[Create invite](/docs/{lang}/api-reference/register/person/invite) — the token\nis delivered to the new user (e-mail link, magic link, etc.) and must be\nposted back here together with the credentials.\n\nConnect decrypts the invite token with its private key, verifies the\norganization and `personId` it carries, and only then writes the User\nrecord. The `personId` of the returned User equals the `idPerson` used in\nthe invite — that's the binding between the two services.",
                        "body": {
                            "mode": "raw",
                            "raw": "{\n    \"inviteToken\": \"<inviteToken>\",\n    \"login\": \"maria.silva\",\n    \"password\": \"S3cretPass!\",\n    \"type\": \"user\"\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    },
                    "response": [
                        {
                            "name": "User created",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/user",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "user"
                                    ]
                                },
                                "description": "Wires Connect login credentials (`login` + `password`) to an existing\nperson registered in Register.\n\nThis is the **second step** of the user-onboarding flow. The first step is to\nissue an invite token for that person at\n[Create invite](/docs/{lang}/api-reference/register/person/invite) — the token\nis delivered to the new user (e-mail link, magic link, etc.) and must be\nposted back here together with the credentials.\n\nConnect decrypts the invite token with its private key, verifies the\norganization and `personId` it carries, and only then writes the User\nrecord. The `personId` of the returned User equals the `idPerson` used in\nthe invite — that's the binding between the two services.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"inviteToken\": \"<inviteToken>\",\n    \"login\": \"maria.silva\",\n    \"password\": \"S3cretPass!\",\n    \"type\": \"user\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"organization\": \"acme\",\n    \"login\":        \"maria.silva\",\n    \"type\":         \"user\",\n    \"personId\":     44,\n    \"pass\":         \"**************\",\n    \"dateTime\":     \"2026-05-01T12:34:56-03:00\"\n}"
                        },
                        {
                            "name": "Token is for a different organization",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/user",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "user"
                                    ]
                                },
                                "description": "Wires Connect login credentials (`login` + `password`) to an existing\nperson registered in Register.\n\nThis is the **second step** of the user-onboarding flow. The first step is to\nissue an invite token for that person at\n[Create invite](/docs/{lang}/api-reference/register/person/invite) — the token\nis delivered to the new user (e-mail link, magic link, etc.) and must be\nposted back here together with the credentials.\n\nConnect decrypts the invite token with its private key, verifies the\norganization and `personId` it carries, and only then writes the User\nrecord. The `personId` of the returned User equals the `idPerson` used in\nthe invite — that's the binding between the two services.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"inviteToken\": \"<inviteToken>\",\n    \"login\": \"maria.silva\",\n    \"password\": \"S3cretPass!\",\n    \"type\": \"user\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Bad Request",
                            "code": 400,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{ \"error\": \"forbidden\", \"message\": \"You don't have permission to create a user for this organization\" }"
                        },
                        {
                            "name": "Login already exists",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/user",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "user"
                                    ]
                                },
                                "description": "Wires Connect login credentials (`login` + `password`) to an existing\nperson registered in Register.\n\nThis is the **second step** of the user-onboarding flow. The first step is to\nissue an invite token for that person at\n[Create invite](/docs/{lang}/api-reference/register/person/invite) — the token\nis delivered to the new user (e-mail link, magic link, etc.) and must be\nposted back here together with the credentials.\n\nConnect decrypts the invite token with its private key, verifies the\norganization and `personId` it carries, and only then writes the User\nrecord. The `personId` of the returned User equals the `idPerson` used in\nthe invite — that's the binding between the two services.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\n    \"inviteToken\": \"<inviteToken>\",\n    \"login\": \"maria.silva\",\n    \"password\": \"S3cretPass!\",\n    \"type\": \"user\"\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Bad Request",
                            "code": 400,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{ \"error\": \"duplicate\", \"message\": \"Access to maria.silva has already been created\" }"
                        }
                    ]
                },
                {
                    "name": "Get User",
                    "request": {
                        "method": "GET",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/user/{{personId}}",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "user",
                                "{{personId}}"
                            ]
                        },
                        "description": "Returns the user record (login, type, organization) for the given person ID."
                    },
                    "response": [
                        {
                            "name": "OK. `disabledAt` is `null` for active users, or the deactivation timestamp when the login is inactive.",
                            "originalRequest": {
                                "method": "GET",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/user/{{personId}}",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "user",
                                        "{{personId}}"
                                    ]
                                },
                                "description": "Returns the user record (login, type, organization) for the given person ID."
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"personId\": 44,\n    \"login\": \"maria.silva\",\n    \"disabledAt\": null\n}"
                        }
                    ]
                },
                {
                    "name": "Person IDs by Login Status",
                    "request": {
                        "method": "GET",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/users/person-ids",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "users",
                                "person-ids"
                            ]
                        },
                        "description": "Returns all staff/admin person IDs grouped by login status (active, inactive, invitePending). No pagination — returns simple integer arrays. Lightweight endpoint (~3 KB for 500 people) used by the admin panel to determine login status without fetching full user records."
                    },
                    "response": [
                        {
                            "name": "OK. Four arrays of integer person IDs grouped by login status.",
                            "originalRequest": {
                                "method": "GET",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/users/person-ids",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "users",
                                        "person-ids"
                                    ]
                                },
                                "description": "Returns all staff/admin person IDs grouped by login status (active, inactive, invitePending). No pagination — returns simple integer arrays. Lightweight endpoint (~3 KB for 500 people) used by the admin panel to determine login status without fetching full user records."
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"all\": [1, 5, 12, 45, 89],\n    \"active\": [1, 5, 12, 45],\n    \"inactive\": [89],\n    \"invitePending\": [12, 45]\n}"
                        }
                    ]
                },
                {
                    "name": "Users Status (batch)",
                    "request": {
                        "method": "POST",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/users/status",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "users",
                                "status"
                            ]
                        },
                        "description": "Returns the active/inactive status for a list of person IDs in a single call. Only person IDs that actually have a login (connect user) in the organization are returned. Used by the admin panel user list to render the status badge without one request per row.",
                        "body": {
                            "mode": "raw",
                            "raw": "{\r\n    \"personIds\": [44, 51, 77]\r\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    },
                    "response": [
                        {
                            "name": "OK. One entry per person ID that has a login; missing IDs simply have no login.",
                            "originalRequest": {
                                "method": "POST",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/users/status",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "users",
                                        "status"
                                    ]
                                },
                                "description": "Returns the active/inactive status for a list of person IDs in a single call. Only person IDs that actually have a login (connect user) in the organization are returned. Used by the admin panel user list to render the status badge without one request per row.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\r\n    \"personIds\": [44, 51, 77]\r\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "[\n    { \"personId\": 44, \"active\": true },\n    { \"personId\": 51, \"active\": false }\n]"
                        }
                    ]
                },
                {
                    "name": "Token",
                    "item": [
                        {
                            "name": "Access token",
                            "request": {
                                "method": "GET",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/authToken/byPerson/{{personId}}",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "authToken",
                                        "byPerson",
                                        "{{personId}}"
                                    ]
                                },
                                "description": "Creates a 30-day access token for the given person ID and returns it."
                            },
                            "response": [
                                {
                                    "name": "Success",
                                    "originalRequest": {
                                        "method": "GET",
                                        "header": [
                                            {
                                                "key": "x-guper-authorization",
                                                "value": "{{x-guper-authorization}}",
                                                "type": "text",
                                                "description": "User token issued by Guper."
                                            },
                                            {
                                                "key": "Content-Type",
                                                "value": "{{Content-Type}}",
                                                "type": "text",
                                                "description": "Always `application/json` for endpoints that accept a JSON body."
                                            }
                                        ],
                                        "url": {
                                            "raw": "https://{{organization}}.myguper.com/api/connect/authToken/byPerson/{{personId}}",
                                            "protocol": "https",
                                            "host": [
                                                "{{organization}}",
                                                "myguper",
                                                "com"
                                            ],
                                            "path": [
                                                "api",
                                                "connect",
                                                "authToken",
                                                "byPerson",
                                                "{{personId}}"
                                            ]
                                        },
                                        "description": "Creates a 30-day access token for the given person ID and returns it."
                                    },
                                    "status": "OK",
                                    "code": 200,
                                    "_postman_previewlanguage": "json",
                                    "header": [
                                        {
                                            "key": "Content-Type",
                                            "value": "application/json"
                                        }
                                    ],
                                    "body": "{\n    \"organization\": \"acme\",\n    \"personId\": \"123456\",\n    \"token\": \"AEFB631DE1E07B31\"\n}"
                                }
                            ]
                        },
                        {
                            "name": "Auth",
                            "request": {
                                "method": "GET",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/authToken/{{token}}",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "authToken",
                                        "{{token}}"
                                    ]
                                },
                                "description": "Issues an authorization token from your API key + secret."
                            },
                            "response": [
                                {
                                    "name": "Success",
                                    "originalRequest": {
                                        "method": "GET",
                                        "header": [
                                            {
                                                "key": "x-guper-authorization",
                                                "value": "{{x-guper-authorization}}",
                                                "type": "text",
                                                "description": "User token issued by Guper."
                                            },
                                            {
                                                "key": "Content-Type",
                                                "value": "{{Content-Type}}",
                                                "type": "text",
                                                "description": "Always `application/json` for endpoints that accept a JSON body."
                                            }
                                        ],
                                        "url": {
                                            "raw": "https://{{organization}}.myguper.com/api/connect/authToken/{{token}}",
                                            "protocol": "https",
                                            "host": [
                                                "{{organization}}",
                                                "myguper",
                                                "com"
                                            ],
                                            "path": [
                                                "api",
                                                "connect",
                                                "authToken",
                                                "{{token}}"
                                            ]
                                        },
                                        "description": "Issues an authorization token from your API key + secret."
                                    },
                                    "status": "OK",
                                    "code": 200,
                                    "_postman_previewlanguage": "json",
                                    "header": [
                                        {
                                            "key": "Content-Type",
                                            "value": "application/json"
                                        }
                                    ],
                                    "body": "{\n    \"personId\": 123456,\n    \"login\": \"tintim@guper.com\",\n    \"type\": \"user\"\n}"
                                }
                            ]
                        }
                    ]
                },
                {
                    "name": "Update User",
                    "request": {
                        "method": "PUT",
                        "header": [
                            {
                                "key": "x-guper-authorization",
                                "value": "{{x-guper-authorization}}",
                                "type": "text",
                                "description": "User token issued by Guper."
                            },
                            {
                                "key": "Content-Type",
                                "value": "{{Content-Type}}",
                                "type": "text",
                                "description": "Always `application/json` for endpoints that accept a JSON body."
                            }
                        ],
                        "url": {
                            "raw": "https://{{organization}}.myguper.com/api/connect/user",
                            "protocol": "https",
                            "host": [
                                "{{organization}}",
                                "myguper",
                                "com"
                            ],
                            "path": [
                                "api",
                                "connect",
                                "user"
                            ]
                        },
                        "description": "Updates **one** user login of the organization. `personId` and `login`\nmust both be sent and must belong to the same user: the `login` locates\nthe record and the `personId` confirms it, so a wrong pair changes\nnothing and answers `404` or `409`.\n\nOnly `password`, `type` and `active` can be changed. Fields you omit stay\nas they are.",
                        "body": {
                            "mode": "raw",
                            "raw": "{\r\n    \"personId\": \"44\",\r\n    \"login\": \"tintim\",\r\n    \"password\": \"a10b20c30\",\r\n    \"active\": false\r\n}",
                            "options": {
                                "raw": {
                                    "language": "json"
                                }
                            }
                        }
                    },
                    "response": [
                        {
                            "name": "User updated",
                            "originalRequest": {
                                "method": "PUT",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/user",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "user"
                                    ]
                                },
                                "description": "Updates **one** user login of the organization. `personId` and `login`\nmust both be sent and must belong to the same user: the `login` locates\nthe record and the `personId` confirms it, so a wrong pair changes\nnothing and answers `404` or `409`.\n\nOnly `password`, `type` and `active` can be changed. Fields you omit stay\nas they are.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\r\n    \"personId\": \"44\",\r\n    \"login\": \"tintim\",\r\n    \"password\": \"a10b20c30\",\r\n    \"active\": false\r\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 200,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"affectedRows\": 1\n}"
                        },
                        {
                            "name": "`personId` or `login` missing — or the new password was used before",
                            "originalRequest": {
                                "method": "PUT",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/user",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "user"
                                    ]
                                },
                                "description": "Updates **one** user login of the organization. `personId` and `login`\nmust both be sent and must belong to the same user: the `login` locates\nthe record and the `personId` confirms it, so a wrong pair changes\nnothing and answers `404` or `409`.\n\nOnly `password`, `type` and `active` can be changed. Fields you omit stay\nas they are.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\r\n    \"personId\": \"44\",\r\n    \"login\": \"tintim\",\r\n    \"password\": \"a10b20c30\",\r\n    \"active\": false\r\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Bad Request",
                            "code": 400,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"status_code\":   400,\n    \"reason_phrase\": \"Bad Request\",\n    \"message\":       \"The 'personId' and 'login' parameters are required\"\n}"
                        },
                        {
                            "name": "No user with that `login` in this organization",
                            "originalRequest": {
                                "method": "PUT",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/user",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "user"
                                    ]
                                },
                                "description": "Updates **one** user login of the organization. `personId` and `login`\nmust both be sent and must belong to the same user: the `login` locates\nthe record and the `personId` confirms it, so a wrong pair changes\nnothing and answers `404` or `409`.\n\nOnly `password`, `type` and `active` can be changed. Fields you omit stay\nas they are.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\r\n    \"personId\": \"44\",\r\n    \"login\": \"tintim\",\r\n    \"password\": \"a10b20c30\",\r\n    \"active\": false\r\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "Not Found",
                            "code": 404,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"status_code\":   404,\n    \"reason_phrase\": \"Not Found\",\n    \"message\":       \"The 'login' provided was not found\"\n}"
                        },
                        {
                            "name": "The `login` exists but belongs to another `personId`",
                            "originalRequest": {
                                "method": "PUT",
                                "header": [
                                    {
                                        "key": "x-guper-authorization",
                                        "value": "{{x-guper-authorization}}",
                                        "type": "text",
                                        "description": "User token issued by Guper."
                                    },
                                    {
                                        "key": "Content-Type",
                                        "value": "{{Content-Type}}",
                                        "type": "text",
                                        "description": "Always `application/json` for endpoints that accept a JSON body."
                                    }
                                ],
                                "url": {
                                    "raw": "https://{{organization}}.myguper.com/api/connect/user",
                                    "protocol": "https",
                                    "host": [
                                        "{{organization}}",
                                        "myguper",
                                        "com"
                                    ],
                                    "path": [
                                        "api",
                                        "connect",
                                        "user"
                                    ]
                                },
                                "description": "Updates **one** user login of the organization. `personId` and `login`\nmust both be sent and must belong to the same user: the `login` locates\nthe record and the `personId` confirms it, so a wrong pair changes\nnothing and answers `404` or `409`.\n\nOnly `password`, `type` and `active` can be changed. Fields you omit stay\nas they are.",
                                "body": {
                                    "mode": "raw",
                                    "raw": "{\r\n    \"personId\": \"44\",\r\n    \"login\": \"tintim\",\r\n    \"password\": \"a10b20c30\",\r\n    \"active\": false\r\n}",
                                    "options": {
                                        "raw": {
                                            "language": "json"
                                        }
                                    }
                                }
                            },
                            "status": "OK",
                            "code": 409,
                            "_postman_previewlanguage": "json",
                            "header": [
                                {
                                    "key": "Content-Type",
                                    "value": "application/json"
                                }
                            ],
                            "body": "{\n    \"status_code\":   409,\n    \"reason_phrase\": \"Conflict\",\n    \"message\":       \"The 'login' provided belongs to another user\"\n}"
                        }
                    ]
                }
            ]
        }
    ],
    "variable": [
        {
            "key": "scheme",
            "value": "https",
            "type": "string"
        },
        {
            "key": "organization",
            "value": "acme",
            "type": "string"
        },
        {
            "key": "TID",
            "value": "tx_demo_a1b2c3d4",
            "type": "string"
        },
        {
            "key": "confirmToken",
            "value": "54eb6281f4e3e13671a5e4c95609f4a69247a5f38d01bef99768399bb6645c49",
            "type": "string"
        },
        {
            "key": "hash",
            "value": "h_demo_abc123def456",
            "type": "string"
        },
        {
            "key": "id",
            "value": "42",
            "type": "string"
        },
        {
            "key": "personId",
            "value": "1234",
            "type": "string"
        },
        {
            "key": "couponCode",
            "value": "DEMO20",
            "type": "string"
        },
        {
            "key": "transactionId",
            "value": "tx_demo_a1b2c3d4",
            "type": "string"
        },
        {
            "key": "dateStart",
            "value": "2024-04-01",
            "type": "string"
        },
        {
            "key": "dateEnd",
            "value": "2024-04-30",
            "type": "string"
        },
        {
            "key": "x-guper-authorization",
            "value": "48c70a3d6bc1d15104abfaee80c6010f348713f5315bfd12028c2455667685a2",
            "type": "string"
        },
        {
            "key": "Content-Type",
            "value": "application/json",
            "type": "string"
        },
        {
            "key": "User-Agent",
            "value": "guper-docs/2.x",
            "type": "string"
        },
        {
            "key": "environment",
            "value": "",
            "type": "string"
        }
    ]
}