openapi.json

{
  "openapi": "3.0.0",
  "info": {
    "title": "Gokapi",
    "description": "[https://github.com/Forceu/Gokapi](https://github.com/Forceu/Gokapi)\n",
    "version": "2.2.5-dev"
  },
  "servers": [
    {
      "url": "/api/",
      "description": "Target Server"
    }
  ],
  "security": [
    {
      "apikey": [
        "VIEW",
        "UPLOAD",
        "DELETE",
        "API_MANAGE"
      ]
    }
  ],
  "tags": [
    {
      "name": "info"
    },
    {
      "name": "files"
    },
    {
      "name": "auth"
    },
    {
      "name": "uploadrequest"
    },
    {
      "name": "user"
    },
    {
      "name": "chunk"
    },
    {
      "name": "logs"
    }
  ],
  "paths": {
    "/info/version": {
      "get": {
        "tags": [
          "info"
        ],
        "summary": "Outputs Gokapi version",
        "description": "This API call returns the Gokapi server version in a readable format and as an integer.",
        "operationId": "version",
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/VersionInfo"
                }
              }
            }
          },
          "401": {
            "description": "Invalid API key provided for authentication"
          }
        }
      }
    },
    "/info/config": {
      "get": {
        "tags": [
          "info"
        ],
        "summary": "Outputs Gokapi upload parameters",
        "description": "This API call returns the Gokapi server upload parameters. All filesizes are in unit Megabyte. Requires API permission UPLOAD",
        "operationId": "uploadconfig",
        "security": [
          {
            "apikey": [
              "UPLOAD"
            ]
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ConfigInfo"
                }
              }
            }
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    },
    "/files/downloadzip": {
      "get": {
        "tags": [
          "files"
        ],
        "summary": "Downloads files as ZIP file with optionally increasing the download counter",
        "description": "This API call downloads multiple file that are not expired and increasing their download counter is disabled by default. Can be set up to return a pre-signed URL instead of the zip file itself, which is valid for 30 seconds and can be accessed by any registered user. End-to-end encrypted files and encrypted files stored on cloud servers cannot be downloaded. Returns 404 if an invalid/expired ID was passed. Requires API permission DOWNLOAD. To download files that were not uploaded by the user, the user needs to have the user permission LIST",
        "operationId": "downloadzip",
        "parameters": [
          {
            "name": "ids",
            "in": "header",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "IDs of files to be downloaded seperated by comma"
          },
          {
            "name": "filename",
            "in": "header",
            "required": false,
            "schema": {
              "type": "string"
            },
            "description": "The filename for the new Zip file. If the filename includes non-ANSI characters, you can encode them with base64, by adding 'base64:' at the beginning, e.g. 'base64:ZmlsZW5hbWU='"
          },
          {
            "name": "increaseCounter",
            "in": "header",
            "required": false,
            "schema": {
              "type": "boolean"
            },
            "description": "Increase counter if set to true"
          },
          {
            "name": "isFileRequestId",
            "in": "header",
            "required": false,
            "schema": {
              "type": "boolean"
            },
            "description": "If true, the passed ID is treated as a File Request ID and all files from the file request are downloaded. Only a single ID can be supplied when isFileRequestId is true"
          },
          {
            "name": "presignUrl",
            "in": "header",
            "required": false,
            "schema": {
              "type": "boolean"
            },
            "description": "Return a pre-signed URL instead of the actual file. Valid for one download within 30 seconds and can only be used by logged in users. When this option is set, download counter cannot be increased."
          }
        ],
        "security": [
          {
            "apikey": [
              "DOWNLOAD"
            ]
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/octet-stream": {
                "schema": {
                  "type": "object",
                  "format": "binary"
                }
              },
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "Result": {
                      "type": "string",
                      "example": "OK"
                    },
                    "downloadUrl": {
                      "type": "string",
                      "format": "uri",
                      "example": "http://gokapi.local:53842/downloadPresigned?key=xieph5ae1leph6Heel0Hoo9uth1eiY9xei8IiboPoothie0ahm6tutufoo2s"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid input or trying to download an end-to-end encrypted file"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "Invalid ID provided or file has expired"
          }
        }
      }
    },
    "/files/download/{id}": {
      "get": {
        "tags": [
          "files"
        ],
        "summary": "Downloads file with optionally increasing the download counter",
        "description": "This API call downloads a file that is not expired and increasing its download counter is disabled by default. Can be set up to return a pre-signed URL instead of the file itself, which is valid for 30 seconds and can be accessed by any registered user. End-to-end encrypted files and encrypted files stored on cloud servers cannot be downloaded. Returns 404 if an invalid/expired ID was passed. Requires API permission DOWNLOAD. To download files that were not uploaded by the user, the user needs to have the user permission LIST",
        "operationId": "downloadsingle",
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "ID of file to be downloaded"
          },
          {
            "name": "increaseCounter",
            "in": "header",
            "required": false,
            "schema": {
              "type": "boolean"
            },
            "description": "Increase counter if set to true"
          },
          {
            "name": "presignUrl",
            "in": "header",
            "required": false,
            "schema": {
              "type": "boolean"
            },
            "description": "Return a pre-signed URL instead of the actual file. Valid for one download within 30 seconds and can only be used by logged in users. When this option is set, download counter cannot be increased."
          }
        ],
        "security": [
          {
            "apikey": [
              "DOWNLOAD"
            ]
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/octet-stream": {
                "schema": {
                  "type": "object",
                  "format": "binary"
                }
              },
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "Result": {
                      "type": "string",
                      "example": "OK"
                    },
                    "downloadUrl": {
                      "type": "string",
                      "format": "uri",
                      "example": "http://gokapi.local:53842/downloadPresigned?key=xieph5ae1leph6Heel0Hoo9uth1eiY9xei8IiboPoothie0ahm6tutufoo2s"
                    }
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid input or trying to download an end-to-end encrypted file"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "Invalid ID provided or file has expired"
          }
        }
      }
    },
    "/files/list": {
      "get": {
        "tags": [
          "files"
        ],
        "summary": "Lists all files",
        "description": "This API call lists all files that are not expired. Returns null, if no files are stored. Requires API permission VIEW. To view files that were not uploaded by the user, the user needs to have the user permission LIST",
        "operationId": "list",
        "security": [
          {
            "apikey": [
              "VIEW"
            ]
          }
        ],
        "parameters": [
          {
            "name": "showFileRequests",
            "in": "header",
            "required": false,
            "schema": {
              "type": "boolean"
            },
            "description": "Set to true, to include files uploaded through file requests"
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "nullable": true,
                  "items": {
                    "$ref": "#/components/schemas/File"
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    },
    "/files/list/{id}": {
      "get": {
        "tags": [
          "files"
        ],
        "summary": "Get metadata by ID",
        "description": "This API call lists all metadata about a file that is not expired. Returns 404 if an invalid/expired ID was passed. Requires API permission VIEW. To view files that were not uploaded by the user, the user needs to have the user permission LIST",
        "operationId": "listbyid",
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "ID of file to be requested"
          }
        ],
        "security": [
          {
            "apikey": [
              "VIEW"
            ]
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/File"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "Invalid ID provided or file has expired"
          }
        }
      }
    },
    "/chunk/add": {
      "post": {
        "tags": [
          "chunk"
        ],
        "summary": "Uploads a new chunk",
        "description": "Uploads a file in chunks, in case a reverse proxy does not support upload of larger files. Parallel uploading is supported. Must call /chunk/complete after all chunks have been uploaded. WARNING: Does not support end-to-end encryption! If server is setup to utilise end-to-end encryption, file will be stored in plain-text! To upload an end-to-end encrypted file, use gokapi-cli. Chunks must be at least 5MB in size, unless last chunk of file. Requires API permission UPLOAD",
        "operationId": "chunkadd",
        "security": [
          {
            "apikey": [
              "UPLOAD"
            ]
          }
        ],
        "requestBody": {
          "content": {
            "multipart/form-data": {
              "schema": {
                "$ref": "#/components/schemas/chunking"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/chunkUploadResult"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    },
    "/chunk/complete": {
      "post": {
        "tags": [
          "chunk"
        ],
        "summary": "Finalises uploaded chunks",
        "description": "Needs to be called after all chunks have been uploaded. Adds the uploaded file to Gokapi. Requires API permission UPLOAD",
        "operationId": "chunkcomplete",
        "security": [
          {
            "apikey": [
              "UPLOAD"
            ]
          }
        ],
        "parameters": [
          {
            "name": "uuid",
            "in": "header",
            "description": "The unique ID that was used for the uploaded chunks",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "filename",
            "in": "header",
            "description": "The filename of the uploaded file. If the filename includes non-ANSI characters, you can encode them with base64, by adding 'base64:' at the beginning, e.g. 'base64:ZmlsZW5hbWU='",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "filesize",
            "in": "header",
            "description": "The total filesize of the uploaded file in bytes",
            "required": true,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "contenttype",
            "in": "header",
            "description": "The MIME content type. If empty, application/octet-stream will be used.",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "allowedDownloads",
            "in": "header",
            "description": "How many downloads are allowed. Default of 1 will be used if empty. Unlimited if 0 is passed.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "expiryDays",
            "in": "header",
            "description": "How many days the file will be stored. Default of 14 will be used if empty. Unlimited if 0 is passed.",
            "required": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "password",
            "in": "header",
            "description": "Password for this file to be set. No password will be used if empty.",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "nonblocking",
            "in": "header",
            "description": "If set to true, the call returns without waiting for the file processing to finish.",
            "required": false,
            "schema": {
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UploadResult"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    },
    "/uploadrequest/chunk/reserve": {
      "post": {
        "tags": [
          "uploadrequest"
        ],
        "summary": "Requests a UUID for uploading a new file for a file request",
        "description": "Requests an UUID that can be used for uplading a new file. The chunks for the new file have to use this UUID. The first chunk needs to be uploaded latest 4 minutes after requesting the UUID. Requires API key associated with the file request",
        "operationId": "chunkreserve",
        "security": [
          {
            "apikey": [
              "SPECIFIC_GUEST_API_KEY"
            ]
          }
        ],
        "parameters": [
          {
            "name": "id",
            "in": "header",
            "description": "The file request ID",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/chunkReserveResult"
                }
              }
            }
          },
          "400": {
            "description": "Invalid ID or the file request does not accept any more files"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "429": {
            "description": "If too many chunks are currently requested, the caller has to wait a couple of seconds and try again. The rate limit is only for file requests that are not limited in file count"
          }
        }
      }
    },
    "/uploadrequest/chunk/unreserve": {
      "post": {
        "tags": [
          "uploadrequest"
        ],
        "summary": "Frees a reserved UUID if upload was cancelled",
        "description": "This call frees a reserved UUID, so that it does not count towards the quota anymore. Used if an upload was cancelled or failed. Requires API key associated with the file request",
        "operationId": "chunkunreserve",
        "security": [
          {
            "apikey": [
              "SPECIFIC_GUEST_API_KEY"
            ]
          }
        ],
        "parameters": [
          {
            "name": "id",
            "in": "header",
            "description": "The file request ID",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "uuid",
            "in": "header",
            "description": "The reserved UUID",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {}
            }
          },
          "400": {
            "description": "Invalid ID or the file request does not accept any more files"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "429": {
            "description": "If too many chunks are currently requested, the caller has to wait a couple of seconds and try again. The rate limit is only for file requests that are not limited in file count"
          }
        }
      }
    },
    "/uploadrequest/chunk/add": {
      "post": {
        "tags": [
          "uploadrequest"
        ],
        "summary": "Uploads a new chunk for a file request",
        "description": "Uploads a file in chunks. Parallel uploading is supported. Must call /uploadrequest/chunk/reserve to request an UUID first and must call /uploadrequest/chunk/complete after all chunks have been uploaded. WARNING: Does not support end-to-end encryption! If server is setup to utilise end-to-end encryption, file will be stored in plain-text! Chunks must be at least 5MB in size, unless last chunk of file. Requires API key associated with the file request",
        "operationId": "chunkaddur",
        "security": [
          {
            "apikey": [
              "SPECIFIC_GUEST_API_KEY"
            ]
          }
        ],
        "parameters": [
          {
            "name": "fileRequestId",
            "in": "header",
            "description": "The ID of the upload request",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "multipart/form-data": {
              "schema": {
                "$ref": "#/components/schemas/chunking"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/chunkUploadResult"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    },
    "/uploadrequest/chunk/complete": {
      "post": {
        "tags": [
          "uploadrequest"
        ],
        "summary": "Finalises uploaded chunks",
        "description": "Needs to be called after all chunks have been uploaded. Adds the uploaded file to Gokapi. Requires API key associated with the file request",
        "operationId": "chunkurcomplete",
        "security": [
          {
            "apikey": [
              "SPECIFIC_GUEST_API_KEY"
            ]
          }
        ],
        "parameters": [
          {
            "name": "uuid",
            "in": "header",
            "description": "The unique ID that was used for the uploaded chunks",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "fileRequestId",
            "in": "header",
            "description": "The file request ID that was used for the uploaded chunks",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "filename",
            "in": "header",
            "description": "The filename of the uploaded file. If the filename includes non-ANSI characters, you can encode them with base64, by adding 'base64:' at the beginning, e.g. 'base64:ZmlsZW5hbWU='",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "filesize",
            "in": "header",
            "description": "The total filesize of the uploaded file in bytes",
            "required": true,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "contenttype",
            "in": "header",
            "description": "The MIME content type. If empty, application/octet-stream will be used.",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "nonblocking",
            "in": "header",
            "description": "If set to true, the call returns without waiting for the file processing to finish.",
            "required": false,
            "schema": {
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UploadResult"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    },
    "/logs/get": {
      "get": {
        "tags": [
          "logs"
        ],
        "summary": "Outputs server logs",
        "description": "This API call returns the server logs with an optional cutoff timestamp to only send the newest logs. Requires API permission MANAGE_LOGS",
        "operationId": "logsGet",
        "security": [
          {
            "apikey": [
              "MANAGE_LOGS"
            ]
          }
        ],
        "parameters": [
          {
            "name": "timestamp",
            "in": "header",
            "description": "Optional cutoff timestamp (Unix epoch in seconds) to filter logs",
            "required": false,
            "schema": {
              "type": "integer",
              "format": "int64"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "logEntries": {
                      "type": "string",
                      "description": "The server logs as a string"
                    },
                    "timestamp": {
                      "type": "integer",
                      "format": "int64",
                      "description": "Timestamp of current time"
                    }
                  }
                }
              }
            }
          },
          "401": {
            "description": "Invalid API key provided for authentication"
          }
        }
      }
    },
    "/logs/systemStatus": {
      "get": {
        "tags": [
          "logs"
        ],
        "summary": "Outputs server status information",
        "description": "This API call returns information about the Gokapi server status. Requires API permission MANAGE_LOGS",
        "operationId": "logsSystemStatus",
        "security": [
          {
            "apikey": [
              "MANAGE_LOGS"
            ]
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ServerStatus"
                }
              }
            }
          },
          "401": {
            "description": "Invalid API key provided for authentication"
          }
        }
      }
    },
    "/logs/delete": {
      "delete": {
        "tags": [
          "logs"
        ],
        "summary": "Deletes entries from the logfile",
        "description": "This API call deletes all lines before older than a cutoff date. Requires API permission MANAGE_LOGS and user needs to be admin or super-admin.",
        "operationId": "logsdelete",
        "security": [
          {
            "apikey": [
              "MANAGE_LOGS"
            ]
          }
        ],
        "parameters": [
          {
            "name": "timestamp",
            "in": "header",
            "required": false,
            "schema": {
              "type": "integer"
            },
            "description": "Unix timestamp of cutoff-date. All entries older than this timestamp will be deleted. To delete all entries, pass 0 or do not pass this parameter at all."
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful"
          },
          "400": {
            "description": "Invalid input"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    },
    "/logs/resetTraffic": {
      "delete": {
        "tags": [
          "logs"
        ],
        "summary": "Reset traffic statistic",
        "description": "This API call resets the statistic that counts outgoing traffic. Requires API permission MANAGE_LOGS and user needs to be admin or super-admin.",
        "operationId": "logsresettraffic",
        "security": [
          {
            "apikey": [
              "MANAGE_LOGS"
            ]
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    },
    "/files/add": {
      "post": {
        "tags": [
          "files"
        ],
        "summary": "Adds a new file without chunking",
        "description": "Uploads the submitted file to Gokapi. Please note: This method does not use chunking, therefore if you are behind a reverse proxy or have a provider that limits upload filesizes, this might not work for bigger files (e.g. Cloudflare). WARNING: Does not support end-to-end encryption! If server is setup to utilise end-to-end encryption, file will be stored in plain-text! To upload an end-to-end encrypted file, use gokapi-cli. Requires API permission UPLOAD",
        "operationId": "add",
        "security": [
          {
            "apikey": [
              "UPLOAD"
            ]
          }
        ],
        "requestBody": {
          "content": {
            "multipart/form-data": {
              "schema": {
                "$ref": "#/components/schemas/body"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/UploadResult"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    },
    "/files/duplicate": {
      "post": {
        "tags": [
          "files"
        ],
        "summary": "Duplicates an existing file",
        "description": "This API call duplicates an existing file with new parameters. Requires API permission UPLOAD. To duplicate files that were not uploaded by the user, the user needs to have the user permission LIST",
        "operationId": "duplicate",
        "security": [
          {
            "apikey": [
              "VIEW",
              "UPLOAD"
            ]
          }
        ],
        "parameters": [
          {
            "name": "id",
            "in": "header",
            "required": true,
            "description": "ID of file to be duplicated",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "allowedDownloads",
            "in": "header",
            "required": false,
            "description": "How many downloads are allowed. Original value from web interface will be used if empty. Unlimited if 0 is passed.",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "expiryDays",
            "in": "header",
            "required": false,
            "description": "How many days the file will be stored. Original value from web interface will be used if empty. Unlimited if 0 is passed.",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "password",
            "in": "header",
            "required": false,
            "description": "Password for this file to be set. No password will be used if empty.",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "originalPassword",
            "in": "header",
            "required": false,
            "description": "Set to true to use original password. Field \"password\" will be ignored if set.",
            "schema": {
              "type": "boolean"
            }
          },
          {
            "name": "filename",
            "in": "header",
            "required": false,
            "description": "Sets a new filename. Filename will be unchanged if empty.",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/File"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "Invalid ID provided or file has expired"
          }
        }
      }
    },
    "/files/changeOwner": {
      "put": {
        "tags": [
          "files"
        ],
        "summary": "Changes the owner of an existing file",
        "description": "This API call changes the owner of an existing owner to the new owner id. Requires API permission EDIT and the user must be an administrator or super-administrator. The user needs to have the user permission EDIT",
        "operationId": "changeowner",
        "security": [
          {
            "apikey": [
              "EDIT"
            ]
          }
        ],
        "parameters": [
          {
            "name": "id",
            "in": "header",
            "required": true,
            "description": "ID of file to be edited",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "newOwner",
            "in": "header",
            "required": true,
            "description": "User ID of the new owner",
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/File"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "Invalid ID provided or file has expired"
          }
        }
      }
    },
    "/files/modify": {
      "put": {
        "tags": [
          "files"
        ],
        "summary": "Changes parameters of an uploaded file",
        "description": "This API call changes parameters of an uploaded file. Requires API permission EDIT. To edit files that were not uploaded by the user, the user needs to have the user permission EDIT",
        "operationId": "modifyfile",
        "security": [
          {
            "apikey": [
              "EDIT"
            ]
          }
        ],
        "parameters": [
          {
            "name": "id",
            "in": "header",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "ID of file to be edited"
          },
          {
            "name": "allowedDownloads",
            "in": "header",
            "required": false,
            "schema": {
              "type": "integer"
            },
            "description": "How many remaining downloads are allowed. Unlimited if 0 is passed."
          },
          {
            "name": "expiryTimestamp",
            "in": "header",
            "required": false,
            "schema": {
              "type": "integer"
            },
            "description": "Unix timestamp of the file expiration date. Unlimited if 0 is passed."
          },
          {
            "name": "password",
            "in": "header",
            "required": false,
            "schema": {
              "type": "string"
            },
            "description": "Password for this file to be set. No password will be used if empty."
          },
          {
            "name": "originalPassword",
            "in": "header",
            "required": false,
            "schema": {
              "type": "boolean"
            },
            "description": "Set to true to use the original password. Field \"password\" will be ignored if set."
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/File"
                }
              }
            }
          },
          "400": {
            "description": "Invalid ID supplied or incorrect data type sent"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "Invalid ID provided or file has expired"
          }
        }
      }
    },
    "/files/replace": {
      "put": {
        "tags": [
          "files"
        ],
        "summary": "Replaces an uploaded file",
        "description": "This API replaces the content of an uploaded file with the content of a different (already uplaoded) file. Note: Replacing end-to-end ecrypted files is NOT possible and will result in an error. Requires API permission REPLACE. To replace a file that was not uploaded by the user, the user needs to have the user permission REPLACE_OTHERS. To replace a file with the content uploaded by another user, the user needs to have the user permission LIST. To delete a file after replacing, the API key requires the permission DELETE. To delete a file that does not belong to the user, the user needs to have the permission DELETE_OTHER_FILES.",
        "operationId": "replacefile",
        "security": [
          {
            "apikey": [
              "REPLACE"
            ]
          }
        ],
        "parameters": [
          {
            "name": "id",
            "in": "header",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "ID of file to be replaced"
          },
          {
            "name": "idNewContent",
            "in": "header",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "ID of the file with the new content"
          },
          {
            "name": "deleteNewFile",
            "in": "header",
            "required": false,
            "schema": {
              "type": "boolean"
            },
            "description": "If true, the file with the ID passed in idNewContent will be deleted afterwards"
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/File"
                }
              }
            }
          },
          "400": {
            "description": "Invalid ID supplied or incorrect data type sent"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "Invalid ID provided or file has expired"
          }
        }
      }
    },
    "/files/delete": {
      "delete": {
        "tags": [
          "files"
        ],
        "summary": "Deletes the selected file",
        "description": "This API call deletes the selected file and runs the clean-up procedure which purges all expired files from the data directory. Deletetion can be postponed with the parameter delay to be able to cancel deletion with the call /files/restore.  Requires API permission DELETE. To delete a file that was not uploaded by the user, the user needs to have the user permission DELETE",
        "operationId": "delete",
        "security": [
          {
            "apikey": [
              "DELETE"
            ]
          }
        ],
        "parameters": [
          {
            "name": "id",
            "in": "header",
            "description": "The ID of the file to be deleted",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "delay",
            "in": "header",
            "description": "The number of seconds to wait before deleting the file, in order to be able to restore it with /files/restore",
            "required": false,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "Invalid ID supplied"
          }
        }
      }
    },
    "/files/restore": {
      "post": {
        "tags": [
          "files"
        ],
        "summary": "Restores a file that is pending to be deleted",
        "description": "This API call cancels a pending deletion of the selected file that originally deleted with /files/delete. The call to restore has to be within the timeframe specified in the delay parameter of /files/delete. Requires API permission DELETE. To delete a file that was not uploaded by the user, the user needs to have the user permission DELETE",
        "operationId": "restore",
        "security": [
          {
            "apikey": [
              "DELETE"
            ]
          }
        ],
        "parameters": [
          {
            "name": "id",
            "in": "header",
            "description": "The ID of the file to be restored",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/File"
                }
              }
            }
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "Invalid ID supplied or the file has already been deleted"
          }
        }
      }
    },
    "/auth/create": {
      "post": {
        "tags": [
          "auth"
        ],
        "summary": "Creates a new API key",
        "description": "This API call returns a new API key. The new key does not have any permissions, unless specified. Requires API permission API_MOD",
        "operationId": "create",
        "security": [
          {
            "apikey": [
              "API_MANAGE"
            ]
          }
        ],
        "parameters": [
          {
            "name": "friendlyName",
            "in": "header",
            "description": "The friendly name of the key",
            "required": false,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "basicPermissions",
            "in": "header",
            "description": "If true, basic permissions are automatically granted",
            "required": false,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/NewApiKey"
                }
              }
            }
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    },
    "/auth/friendlyname": {
      "put": {
        "tags": [
          "auth"
        ],
        "summary": "Changes the name of the API key",
        "description": "This API call changes the name of the API key that is shown in the API overview. Requires API permission API_MOD. To change the name of an API key not owned by the user, the user needs to have the user permission API",
        "operationId": "friendlyname",
        "security": [
          {
            "apikey": [
              "API_MANAGE"
            ]
          }
        ],
        "parameters": [
          {
            "name": "targetKey",
            "in": "header",
            "description": "The API key to change the name of. Can be either the public ID or the actual API key",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "friendlyName",
            "in": "header",
            "description": "The new name of a API key",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "API key not found"
          }
        }
      }
    },
    "/auth/modify": {
      "put": {
        "tags": [
          "auth"
        ],
        "summary": "Changes the permissions of the API key",
        "description": "This API call changes the permission for the given API key. Requires API permission API_MOD. To to edit an API key not owned by the user, the user needs to have the user permission API",
        "operationId": "modifypermission",
        "security": [
          {
            "apikey": [
              "API_MANAGE"
            ]
          }
        ],
        "parameters": [
          {
            "name": "targetKey",
            "in": "header",
            "description": "The API key to change the permission of. Can be either the public ID or the actual API key",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "permission",
            "in": "header",
            "description": "The name of the permission",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string",
              "enum": [
                "PERM_VIEW",
                "PERM_UPLOAD",
                "PERM_EDIT",
                "PERM_DELETE",
                "PERM_REPLACE",
                "PERM_MANAGE_FILE_REQUESTS",
                "PERM_MANAGE_LOGS",
                "PERM_MANAGE_USERS",
                "PERM_API_MOD"
              ]
            }
          },
          {
            "name": "permissionModifier",
            "in": "header",
            "description": "If the permission shall be granted or revoked",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string",
              "enum": [
                "GRANT",
                "REVOKE"
              ]
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful"
          },
          "400": {
            "description": "Invalid parameter supplied or API key owner does not have the sufficient user permissions"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "API key not found"
          }
        }
      }
    },
    "/auth/delete": {
      "delete": {
        "tags": [
          "auth"
        ],
        "summary": "Deletes an API key",
        "description": "This API call deletes the given API key. Requires API permission API_MOD. To to delete an API key not owned by the user, the user needs to have the user permission API",
        "operationId": "apidelete",
        "security": [
          {
            "apikey": [
              "API_MANAGE"
            ]
          }
        ],
        "parameters": [
          {
            "name": "targetKey",
            "in": "header",
            "description": "The API key to delete. Can be either the public ID or the actual API key",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful"
          },
          "404": {
            "description": "Invalid ID supplied"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    },
    "/uploadrequest/list": {
      "get": {
        "tags": [
          "uploadrequest"
        ],
        "summary": "Lists all file requests",
        "description": "This API call lists all file requests. Requires API permission MANAGE_FILE_REQUESTS. To view file requests created by a different user, the user needs to have the user permission LIST",
        "operationId": "ulist",
        "security": [
          {
            "apikey": [
              "MANAGE_FILE_REQUESTS"
            ]
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "nullable": false,
                  "items": {
                    "$ref": "#/components/schemas/FileRequest"
                  }
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    },
    "/uploadrequest/list/{id}": {
      "get": {
        "tags": [
          "uploadrequest"
        ],
        "summary": "Get file request by ID",
        "description": "This API call lists a specific file request. Returns 404 if an invalid ID was passed. Requires API permission MANAGE_FILE_REQUESTS. To view file requests from a different user, the user needs to have the user permission LIST",
        "operationId": "ulistbyid",
        "parameters": [
          {
            "name": "id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "ID of file request"
          }
        ],
        "security": [
          {
            "apikey": [
              "MANAGE_FILE_REQUESTS"
            ]
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/FileRequest"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "Invalid ID provided"
          }
        }
      }
    },
    "/uploadrequest/save": {
      "post": {
        "tags": [
          "uploadrequest"
        ],
        "summary": "Creates a new or saves an existing upload request",
        "description": "This API call creates a new upload request if the parameter ID is not submitted. If editing a request, only the submitted parameters will be changed. To save a request of a different user, the user requires the user permission EDIT to execute this call. Requires API permission MANAGE_FILE_REQUESTS",
        "operationId": "uploadrequestsave",
        "security": [
          {
            "apikey": [
              "MANAGE_FILE_REQUESTS"
            ]
          }
        ],
        "parameters": [
          {
            "name": "id",
            "in": "header",
            "description": "The request to be saved. If empty, a new request will be created",
            "required": false,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "name",
            "in": "header",
            "description": "The given name for the request. If the name includes non-ANSI characters, you can encode them with base64, by adding 'base64:' at the beginning, e.g. 'base64:ZmlsZW5hbWU='",
            "required": false,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "notes",
            "in": "header",
            "description": "The public notes for the request. If the notes includes non-ANSI characters, you can encode them with base64, by adding 'base64:' at the beginning, e.g. 'base64:ZmlsZW5hbWU='",
            "required": false,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "expiry",
            "in": "header",
            "description": "The expiry as a UTC unix timestamp. No expiry if 0",
            "required": false,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "maxfiles",
            "in": "header",
            "description": "The amount of files that can be uploaded. No limit if 0",
            "required": false,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "maxsize",
            "in": "header",
            "description": "The maximum size in Megabytes per file. No limit if 0",
            "required": false,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/FileRequest"
                }
              }
            }
          },
          "400": {
            "description": "Invalid ID or parameters supplied"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "Upload request not found"
          }
        }
      }
    },
    "/uploadrequest/delete": {
      "delete": {
        "tags": [
          "uploadrequest"
        ],
        "summary": "Deletes the upload request and all associated files",
        "description": "This API call deletes the given file requests. If files are associated with the request, they will also be deleted. To delete a request of a different user, the user requires the user permission DELETE to execute this call. Requires API permission MANAGE_FILE_REQUESTS and DELETE",
        "operationId": "uploadrequestdelete",
        "security": [
          {
            "apikey": [
              "MANAGE_FILE_REQUESTS",
              "DELETE"
            ]
          }
        ],
        "parameters": [
          {
            "name": "id",
            "in": "header",
            "description": "The request to be deleted",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful"
          },
          "400": {
            "description": "Invalid ID or parameters supplied"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "Upload request not found"
          }
        }
      }
    },
    "/user/create": {
      "post": {
        "tags": [
          "user"
        ],
        "summary": "Creates a new user",
        "description": "This API call adds a new user. The new user does not have any specific permissions and is userlevel USER. Requires API permission MANAGE_USERS",
        "operationId": "createuser",
        "security": [
          {
            "apikey": [
              "MANAGE_USERS"
            ]
          }
        ],
        "parameters": [
          {
            "name": "username",
            "in": "header",
            "description": "Full name of new user, must be at least 2 characters",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/NewUser"
                }
              }
            }
          },
          "400": {
            "description": "Invalid parameters supplied"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "409": {
            "description": "A user already exists with that email address"
          }
        }
      }
    },
    "/user/modify": {
      "put": {
        "tags": [
          "user"
        ],
        "summary": "Changes the permissions of a user",
        "description": "This API call changes the permission for the given user. Requires API permission MANAGE_USERS",
        "operationId": "usermodify",
        "security": [
          {
            "apikey": [
              "MANAGE_USERS"
            ]
          }
        ],
        "parameters": [
          {
            "name": "userid",
            "in": "header",
            "description": "The ID of the user to change the permission of",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "userpermission",
            "in": "header",
            "description": "The name of the permission",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string",
              "enum": [
                "PERM_REPLACE",
                "PERM_LIST",
                "PERM_EDIT",
                "PERM_REPLACE_OTHER",
                "PERM_DELETE",
                "PERM_LOGS",
                "PERM_API",
                "PERM_USERS",
                "PERM_GUEST_UPLOAD"
              ]
            }
          },
          {
            "name": "permissionModifier",
            "in": "header",
            "description": "If the permission shall be granted or revoked",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string",
              "enum": [
                "GRANT",
                "REVOKE"
              ]
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful"
          },
          "400": {
            "description": "Invalid parameter supplied"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "User not found"
          }
        }
      }
    },
    "/user/changeRank": {
      "put": {
        "tags": [
          "user"
        ],
        "summary": "Changes the rank of a user",
        "description": "This API call changes the rank for the given user. Requires API permission MANAGE_USERS",
        "operationId": "userchangerank",
        "security": [
          {
            "apikey": [
              "MANAGE_USERS"
            ]
          }
        ],
        "parameters": [
          {
            "name": "userid",
            "in": "header",
            "description": "The ID of the user to change the rank of",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "newRank",
            "in": "header",
            "description": "The name of the new rank",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "string",
              "enum": [
                "ADMIN",
                "USER"
              ]
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful"
          },
          "400": {
            "description": "Invalid parameter supplied"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          },
          "404": {
            "description": "User not found"
          }
        }
      }
    },
    "/user/resetPassword": {
      "put": {
        "tags": [
          "user"
        ],
        "summary": "Resets the password of the current user",
        "description": "This API call forces a passwrd change once the given user logs in the next time. If generateNewPassword is \"true\", the current password will be replaced with a generated one.  Requires API permission MANAGE_USERS",
        "operationId": "userresetpw",
        "security": [
          {
            "apikey": [
              "MANAGE_USERS"
            ]
          }
        ],
        "parameters": [
          {
            "name": "userid",
            "in": "header",
            "description": "The id of the target user",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "generateNewPassword",
            "in": "header",
            "description": "Generate a new password",
            "required": false,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PasswordReset"
                }
              }
            }
          },
          "400": {
            "description": "Invalid ID or parameters supplied"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    },
    "/user/delete": {
      "delete": {
        "tags": [
          "user"
        ],
        "summary": "Deletes the selected user",
        "description": "This API call deletes the given user. If files are associated with the user, they will be linked with the user that initiated the deletion. If deleteFiles is \"true\", the files will be deleted instead.  Requires API permission MANAGE_USERS",
        "operationId": "userdelete",
        "security": [
          {
            "apikey": [
              "MANAGE_USERS"
            ]
          }
        ],
        "parameters": [
          {
            "name": "userid",
            "in": "header",
            "description": "The ID of the user to be deleted",
            "required": true,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "deleteFiles",
            "in": "header",
            "description": "Delete all associated uploads from this user",
            "required": false,
            "style": "simple",
            "explode": false,
            "schema": {
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Operation successful"
          },
          "400": {
            "description": "Invalid ID or parameters supplied"
          },
          "401": {
            "description": "Invalid API key provided for authentication or API key does not have the required permission"
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "File": {
        "type": "object",
        "properties": {
          "Id": {
            "type": "string",
            "description": "The internal ID of the file",
            "example": "oNleRD3pUZgaDKn"
          },
          "Name": {
            "type": "string",
            "description": "The filename. Will be 'Encrypted file' for end-to-end encrypted files",
            "example": "Test File.jpg"
          },
          "Size": {
            "type": "string",
            "description": "Filesize in a human readable format",
            "example": "395.4 kB"
          },
          "HotlinkId": {
            "type": "string",
            "description": "If file is a picture file and can be hotlinked, this is the ID for the hotlink",
            "example": "tDMs0U8MvRFwK69PfjagI7F87C13UVeQuOGDvtCG.jpg"
          },
          "ContentType": {
            "description": "The MIME type for the file",
            "type": "string",
            "example": "image/jpeg"
          },
          "ExpireAtString": {
            "type": "string",
            "description": "Time expiry in a human readable format in UTC",
            "example": "2024-02-17 14:08"
          },
          "UrlDownload": {
            "type": "string",
            "description": "The public download URL for the file",
            "example": "https://gokapi.server/d?id=oNleRD3pUZgaDKn"
          },
          "UrlHotlink": {
            "type": "string",
            "description": "The public hotlink URL for the file",
            "example": "https://gokapi.server/h/tDMs0U8MvRFwK69PfjagI7F87C13UVeQuOGDvtCG.jpg"
          },
          "FileRequestId": {
            "type": "string",
            "description": "If the file belongs to an upload request, the ID is set in this field",
            "example": "cnMEWsrMwSx1wyr"
          },
          "UploadDate": {
            "type": "integer",
            "description": "UTC timestamp of file upload",
            "format": "int64",
            "example": "1708175121"
          },
          "ExpireAt": {
            "type": "integer",
            "description": "UTC timestamp of file expiry",
            "format": "int64",
            "example": "1708175321"
          },
          "SizeBytes": {
            "type": "integer",
            "format": "int64",
            "description": "Filesize in bytes",
            "example": "404843"
          },
          "DownloadsRemaining": {
            "type": "integer",
            "description": "The remaining downloads for this file",
            "format": "int64",
            "example": "4"
          },
          "DownloadCount": {
            "type": "integer",
            "description": "The amount of times the file has been downloaded",
            "format": "int64",
            "example": "1"
          },
          "UnlimitedDownloads": {
            "type": "boolean",
            "description": "True if the uploader did not limit the downloads",
            "example": "false"
          },
          "UnlimitedTime": {
            "type": "boolean",
            "description": "True if the uploader did not limit the time",
            "example": "false"
          },
          "RequiresClientSideDecryption": {
            "type": "boolean",
            "description": "True if the file has to be decrypted client-side",
            "example": "false"
          },
          "IsEncrypted": {
            "description": "True if the file is encrypted",
            "type": "boolean",
            "example": "false"
          },
          "IsEndToEndEncrypted": {
            "description": "True if the file is end-to-end encrypted",
            "type": "boolean",
            "example": "false"
          },
          "IsPasswordProtected": {
            "type": "boolean",
            "description": "True if a password has to be entered before downloading the file",
            "example": "false"
          },
          "IsSavedOnLocalStorage": {
            "description": "True if the file does not use cloud storage",
            "type": "boolean",
            "example": "true"
          },
          "IsPendingDeletion": {
            "description": "True if the file is about to be deleted",
            "type": "boolean",
            "example": "false"
          },
          "IsFileRequest": {
            "description": "True if the file belongs to an upload request",
            "type": "boolean",
            "example": "true"
          },
          "UploaderId": {
            "description": "The user ID of the uploader",
            "type": "integer",
            "example": "3"
          }
        },
        "description": "File is a struct used for saving information about an uploaded file",
        "x-go-package": "Gokapi/internal/models"
      },
      "ServerStatus": {
        "type": "object",
        "properties": {
          "uptime": {
            "description": "Time in seconds since Gokapi started",
            "example": "3600",
            "type": "integer",
            "format": "int64"
          },
          "cpuLoad": {
            "description": "CPU load in percent",
            "example": "6",
            "type": "integer",
            "format": "int32"
          },
          "memoryUsagePercentage": {
            "description": "Usage of virtual memory in percent",
            "example": "34",
            "type": "integer",
            "format": "int32"
          },
          "diskUsagePercentage": {
            "description": "Usage of disk space in percent",
            "example": "76",
            "type": "integer",
            "format": "int32"
          },
          "activeFiles": {
            "description": "Count of all downloadable files on the server",
            "example": "670",
            "type": "integer",
            "format": "int32"
          },
          "memoryUsed": {
            "description": "Usage of virtual memory in bytes",
            "example": "22964649984",
            "type": "integer",
            "format": "int64",
            "minimum": 0
          },
          "memoryTotal": {
            "description": "Total virtual memory in bytes",
            "example": "67314262016",
            "type": "integer",
            "format": "int64",
            "minimum": 0
          },
          "diskUsed": {
            "description": "Usage of disk space in bytes",
            "example": "5292891832320",
            "type": "integer",
            "format": "int64",
            "minimum": 0
          },
          "diskTotal": {
            "description": "Total disk space in bytes",
            "example": "6913048707072",
            "type": "integer",
            "format": "int64",
            "minimum": 0
          },
          "dataServed": {
            "description": "Total outgoing traffic in bytes, persistent between sessions",
            "example": "22830562614826",
            "type": "integer",
            "format": "int64",
            "minimum": 0
          },
          "trafficRecordingSince": {
            "description": "Timestamp since when traffic recording started",
            "example": "1769706097",
            "type": "integer",
            "format": "int64"
          }
        },
        "description": "ServerStats is a struct used for passing server status information"
      },
      "FileRequest": {
        "type": "object",
        "description": "Represents a file upload request and its associated metadata.",
        "properties": {
          "id": {
            "type": "string",
            "description": "The internal ID of the file request",
            "example": "caep3Ooquu6phoo"
          },
          "userid": {
            "type": "integer",
            "format": "int32",
            "description": "The user ID of the owner",
            "example": "2"
          },
          "maxfiles": {
            "type": "integer",
            "format": "int32",
            "description": "The maximum number of files allowed or 0 if unlimited",
            "example": "20"
          },
          "maxsize": {
            "type": "integer",
            "format": "int32",
            "description": "The maximum file size allowed in MB or 0 if unlimited",
            "example": "0"
          },
          "CombinedMaxSize": {
            "type": "integer",
            "format": "int32",
            "description": "The lesser of MaxSize and the server's max upload size.",
            "example": "0"
          },
          "expiry": {
            "type": "integer",
            "format": "int64",
            "description": "The expiry time of the file request as a Unix timestamp or 0 if no expiry",
            "example": "1767022842"
          },
          "creationdate": {
            "type": "integer",
            "format": "int64",
            "description": "The timestamp when the file request was created",
            "example": "1767021842"
          },
          "name": {
            "type": "string",
            "description": "The given name for the file request",
            "example": "Book list entries"
          },
          "notes": {
            "type": "string",
            "description": "The public notes for the file request",
            "example": "Please make sure to upload revision 1 files"
          },
          "apikey": {
            "type": "string",
            "description": "The API key that is used for uploading files for this request",
            "example": "wrg5L7ldIUiXd27mIH1Fh0gGIyrekC"
          },
          "uploadedfiles": {
            "type": "integer",
            "format": "int32",
            "description": "The number of uploaded files for this request",
            "example": "3"
          },
          "reserveduploads": {
            "type": "integer",
            "format": "int32",
            "description": "The number of current uploads, which have not been finalised yet",
            "example": "1"
          },
          "lastupload": {
            "type": "integer",
            "format": "int64",
            "description": "The timestamp of the last upload",
            "example": "1767022002"
          },
          "totalfilesize": {
            "type": "integer",
            "format": "int64",
            "description": "The total size of all uploaded files in bytes",
            "example": "544332214"
          },
          "fileidlist": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "An array of the IDs of all uploaded files",
            "example": [
              "cohng2weGh",
              "see5Ohng9y",
              "EoYiog4Che"
            ]
          }
        }
      },
      "chunkUploadResult": {
        "type": "object",
        "properties": {
          "Result": {
            "type": "string",
            "example": "OK"
          }
        },
        "description": "Result after uploading a chunk",
        "x-go-package": "Gokapi/internal/models"
      },
      "chunkReserveResult": {
        "type": "object",
        "properties": {
          "Result": {
            "type": "string",
            "example": "OK"
          },
          "Uuid": {
            "type": "string",
            "example": "naPh9athuyeimie3uu8pingoyi2Sho"
          }
        },
        "description": "Result after uploading a chunk",
        "x-go-package": "Gokapi/internal/models"
      },
      "UploadResult": {
        "type": "object",
        "properties": {
          "Result": {
            "type": "string",
            "example": "OK"
          },
          "FileInfo": {
            "$ref": "#/components/schemas/File"
          },
          "IncludeFilename": {
            "type": "boolean",
            "description": "If true, the download URLs include the filename",
            "example": "true"
          }
        },
        "description": "UploadResult is the struct used for the result after an upload",
        "x-go-package": "Gokapi/internal/models"
      },
      "NewApiKey": {
        "type": "object",
        "properties": {
          "Result": {
            "type": "string",
            "example": "OK"
          },
          "Id": {
            "type": "string",
            "example": "ar3iecahghiethiemeeR"
          },
          "PublicId": {
            "type": "string",
            "example": "oepah5iesae8YeeZohrain5ahNgax8su"
          }
        },
        "description": "NewApiKey is the struct used for the result after creating a new API key",
        "x-go-package": "Gokapi/internal/models"
      },
      "NewUser": {
        "type": "object",
        "properties": {
          "email": {
            "type": "string",
            "example": "user@gokapi"
          },
          "id": {
            "type": "integer",
            "example": 14
          },
          "lastOnline": {
            "type": "integer",
            "example": 0
          },
          "name": {
            "type": "string",
            "example": "Gokapi user"
          },
          "permissions": {
            "type": "integer",
            "example": 0
          },
          "userLevel": {
            "type": "integer",
            "example": 2
          }
        },
        "description": "NewUser is the struct used for the result after creating a new API key",
        "x-go-package": "Gokapi/internal/models"
      },
      "VersionInfo": {
        "type": "object",
        "properties": {
          "Version": {
            "type": "string",
            "example": "2.2.5-dev"
          },
          "VersionInt": {
            "type": "integer",
            "example": 20205
          },
          "EndToEndEncryptionEnabled": {
            "type": "boolean",
            "example": false
          }
        },
        "description": "VersionInfo is the struct used for returning version numbers"
      },
      "ConfigInfo": {
        "type": "object",
        "properties": {
          "MaxFilesize": {
            "type": "integer",
            "example": "100"
          },
          "MaxChunksize": {
            "type": "integer",
            "example": 40
          }
        },
        "description": "ConfigInfo is the struct used for returning configuration data"
      },
      "PasswordReset": {
        "type": "object",
        "properties": {
          "result": {
            "type": "string",
            "example": "OK"
          },
          "password": {
            "type": "string",
            "description": "Empty if no new password was generated, otherwise contains the new password",
            "example": "ahseth6ahV"
          }
        },
        "description": "NewUser is the struct used for the result after creating a new API key",
        "x-go-package": "Gokapi/internal/models"
      },
      "body": {
        "required": [
          "file"
        ],
        "type": "object",
        "properties": {
          "file": {
            "type": "string",
            "description": "The file to be uploaded",
            "format": "binary"
          },
          "allowedDownloads": {
            "type": "integer",
            "description": "How many downloads are allowed. Default of 1 will be used if empty. Unlimited if 0 is passed."
          },
          "expiryDays": {
            "type": "integer",
            "description": "How many days the file will be stored. Default of 14 will be used if empty. Unlimited if 0 is passed."
          },
          "password": {
            "type": "string",
            "description": "Password for this file to be set. No password will be used if empty"
          }
        }
      },
      "chunking": {
        "required": [
          "file",
          "uuid",
          "filesize",
          "offset"
        ],
        "type": "object",
        "properties": {
          "file": {
            "type": "string",
            "description": "The chunk to be uploaded",
            "format": "binary"
          },
          "uuid": {
            "type": "string",
            "description": "A unique ID that has to be the same for all chunks of a single file. Needs to be at least 10 characters long."
          },
          "filesize": {
            "type": "integer",
            "description": "The total filesize of the final file in bytes"
          },
          "offset": {
            "type": "integer",
            "description": "The chunk's offset starting at the beginning of the file"
          }
        }
      }
    },
    "securitySchemes": {
      "apikey": {
        "type": "apiKey",
        "name": "apikey",
        "in": "header"
      }
    }
  }
}