From e90cac77dbefc78d8deea669bd12398b2d6704b1 Mon Sep 17 00:00:00 2001 From: Andrea Mistrali Date: Fri, 28 Jun 2024 17:14:01 +0200 Subject: [PATCH] Much better code --- headscale.openapi.json | 1633 +++++++++++++++++ headscale_api_client/apikeys.py | 44 +- headscale_api_client/model.py | 27 +- headscale_api_client/nodes.py | 80 +- headscale_api_client/preauthkeys.py | 49 + headscale_api_client/routes.py | 32 +- headscale_api_client/schemas.py | 101 + .../schemas/HeadscaleServiceSetTagsBody.py | 12 - headscale_api_client/schemas/__init__.py | 42 - headscale_api_client/schemas/protobufAny.py | 12 - headscale_api_client/schemas/rpcStatus.py | 18 - headscale_api_client/schemas/v1ApiKey.py | 20 - .../schemas/v1BackfillNodeIPsResponse.py | 12 - .../schemas/v1CreateApiKeyRequest.py | 12 - .../schemas/v1CreateApiKeyResponse.py | 12 - .../schemas/v1CreatePreAuthKeyRequest.py | 20 - .../schemas/v1CreatePreAuthKeyResponse.py | 14 - .../schemas/v1CreateUserRequest.py | 12 - .../schemas/v1CreateUserResponse.py | 14 - .../schemas/v1DebugCreateNodeRequest.py | 18 - .../schemas/v1DebugCreateNodeResponse.py | 14 - .../schemas/v1DeleteApiKeyResponse.py | 10 - .../schemas/v1DeleteNodeResponse.py | 10 - .../schemas/v1DeleteRouteResponse.py | 10 - .../schemas/v1DeleteUserResponse.py | 10 - .../schemas/v1DisableRouteResponse.py | 10 - .../schemas/v1EnableRouteResponse.py | 10 - .../schemas/v1ExpireApiKeyRequest.py | 12 - .../schemas/v1ExpireApiKeyResponse.py | 10 - .../schemas/v1ExpireNodeResponse.py | 14 - .../schemas/v1ExpirePreAuthKeyRequest.py | 14 - .../schemas/v1ExpirePreAuthKeyResponse.py | 10 - .../schemas/v1GetNodeResponse.py | 14 - .../schemas/v1GetNodeRoutesResponse.py | 14 - .../schemas/v1GetRoutesResponse.py | 15 - .../schemas/v1GetUserResponse.py | 14 - .../schemas/v1ListApiKeysResponse.py | 14 - .../schemas/v1ListNodesResponse.py | 14 - .../schemas/v1ListPreAuthKeysResponse.py | 14 - .../schemas/v1ListUsersResponse.py | 14 - .../schemas/v1MoveNodeRequest.py | 12 - .../schemas/v1MoveNodeResponse.py | 14 - headscale_api_client/schemas/v1Node.py | 36 - headscale_api_client/schemas/v1PreAuthKey.py | 28 - .../schemas/v1RegisterMethod.py | 9 - .../schemas/v1RegisterNodeResponse.py | 14 - .../schemas/v1RenameNodeResponse.py | 14 - .../schemas/v1RenameUserResponse.py | 14 - headscale_api_client/schemas/v1Route.py | 22 - .../schemas/v1SetTagsResponse.py | 14 - headscale_api_client/schemas/v1User.py | 14 - headscale_api_client/users.py | 40 +- 52 files changed, 1931 insertions(+), 731 deletions(-) create mode 100644 headscale.openapi.json create mode 100644 headscale_api_client/preauthkeys.py create mode 100644 headscale_api_client/schemas.py delete mode 100644 headscale_api_client/schemas/HeadscaleServiceSetTagsBody.py delete mode 100644 headscale_api_client/schemas/__init__.py delete mode 100644 headscale_api_client/schemas/protobufAny.py delete mode 100644 headscale_api_client/schemas/rpcStatus.py delete mode 100644 headscale_api_client/schemas/v1ApiKey.py delete mode 100644 headscale_api_client/schemas/v1BackfillNodeIPsResponse.py delete mode 100644 headscale_api_client/schemas/v1CreateApiKeyRequest.py delete mode 100644 headscale_api_client/schemas/v1CreateApiKeyResponse.py delete mode 100644 headscale_api_client/schemas/v1CreatePreAuthKeyRequest.py delete mode 100644 headscale_api_client/schemas/v1CreatePreAuthKeyResponse.py delete mode 100644 headscale_api_client/schemas/v1CreateUserRequest.py delete mode 100644 headscale_api_client/schemas/v1CreateUserResponse.py delete mode 100644 headscale_api_client/schemas/v1DebugCreateNodeRequest.py delete mode 100644 headscale_api_client/schemas/v1DebugCreateNodeResponse.py delete mode 100644 headscale_api_client/schemas/v1DeleteApiKeyResponse.py delete mode 100644 headscale_api_client/schemas/v1DeleteNodeResponse.py delete mode 100644 headscale_api_client/schemas/v1DeleteRouteResponse.py delete mode 100644 headscale_api_client/schemas/v1DeleteUserResponse.py delete mode 100644 headscale_api_client/schemas/v1DisableRouteResponse.py delete mode 100644 headscale_api_client/schemas/v1EnableRouteResponse.py delete mode 100644 headscale_api_client/schemas/v1ExpireApiKeyRequest.py delete mode 100644 headscale_api_client/schemas/v1ExpireApiKeyResponse.py delete mode 100644 headscale_api_client/schemas/v1ExpireNodeResponse.py delete mode 100644 headscale_api_client/schemas/v1ExpirePreAuthKeyRequest.py delete mode 100644 headscale_api_client/schemas/v1ExpirePreAuthKeyResponse.py delete mode 100644 headscale_api_client/schemas/v1GetNodeResponse.py delete mode 100644 headscale_api_client/schemas/v1GetNodeRoutesResponse.py delete mode 100644 headscale_api_client/schemas/v1GetRoutesResponse.py delete mode 100644 headscale_api_client/schemas/v1GetUserResponse.py delete mode 100644 headscale_api_client/schemas/v1ListApiKeysResponse.py delete mode 100644 headscale_api_client/schemas/v1ListNodesResponse.py delete mode 100644 headscale_api_client/schemas/v1ListPreAuthKeysResponse.py delete mode 100644 headscale_api_client/schemas/v1ListUsersResponse.py delete mode 100644 headscale_api_client/schemas/v1MoveNodeRequest.py delete mode 100644 headscale_api_client/schemas/v1MoveNodeResponse.py delete mode 100644 headscale_api_client/schemas/v1Node.py delete mode 100644 headscale_api_client/schemas/v1PreAuthKey.py delete mode 100644 headscale_api_client/schemas/v1RegisterMethod.py delete mode 100644 headscale_api_client/schemas/v1RegisterNodeResponse.py delete mode 100644 headscale_api_client/schemas/v1RenameNodeResponse.py delete mode 100644 headscale_api_client/schemas/v1RenameUserResponse.py delete mode 100644 headscale_api_client/schemas/v1Route.py delete mode 100644 headscale_api_client/schemas/v1SetTagsResponse.py delete mode 100644 headscale_api_client/schemas/v1User.py diff --git a/headscale.openapi.json b/headscale.openapi.json new file mode 100644 index 0000000..79f8b92 --- /dev/null +++ b/headscale.openapi.json @@ -0,0 +1,1633 @@ +{ + "openapi": "3.0.1", + "info": { + "title": "headscale/v1/headscale.proto", + "version": "version not set" + }, + "servers": [ + { + "url": "/" + } + ], + "tags": [ + { + "name": "HeadscaleService" + } + ], + "paths": { + "/api/v1/apikey": { + "get": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_ListApiKeys", + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1ListApiKeysResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + }, + "post": { + "tags": [ + "HeadscaleService" + ], + "summary": "--- ApiKeys start ---", + "operationId": "HeadscaleService_CreateApiKey", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1CreateApiKeyRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1CreateApiKeyResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + }, + "x-codegen-request-body-name": "body" + } + }, + "/api/v1/apikey/expire": { + "post": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_ExpireApiKey", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1ExpireApiKeyRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1ExpireApiKeyResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + }, + "x-codegen-request-body-name": "body" + } + }, + "/api/v1/apikey/{prefix}": { + "delete": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_DeleteApiKey", + "parameters": [ + { + "name": "prefix", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1DeleteApiKeyResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/debug/node": { + "post": { + "tags": [ + "HeadscaleService" + ], + "summary": "--- Node start ---", + "operationId": "HeadscaleService_DebugCreateNode", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1DebugCreateNodeRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1DebugCreateNodeResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + }, + "x-codegen-request-body-name": "body" + } + }, + "/api/v1/node": { + "get": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_ListNodes", + "parameters": [ + { + "name": "user", + "in": "query", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1ListNodesResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/node/backfillips": { + "post": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_BackfillNodeIPs", + "parameters": [ + { + "name": "confirmed", + "in": "query", + "schema": { + "type": "boolean" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1BackfillNodeIPsResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/node/register": { + "post": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_RegisterNode", + "parameters": [ + { + "name": "user", + "in": "query", + "schema": { + "type": "string" + } + }, + { + "name": "key", + "in": "query", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1RegisterNodeResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/node/{nodeId}": { + "get": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_GetNode", + "parameters": [ + { + "name": "nodeId", + "in": "path", + "required": true, + "schema": { + "type": "string", + "format": "uint64" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1GetNodeResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + }, + "delete": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_DeleteNode", + "parameters": [ + { + "name": "nodeId", + "in": "path", + "required": true, + "schema": { + "type": "string", + "format": "uint64" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1DeleteNodeResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/node/{nodeId}/expire": { + "post": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_ExpireNode", + "parameters": [ + { + "name": "nodeId", + "in": "path", + "required": true, + "schema": { + "type": "string", + "format": "uint64" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1ExpireNodeResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/node/{nodeId}/rename/{newName}": { + "post": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_RenameNode", + "parameters": [ + { + "name": "nodeId", + "in": "path", + "required": true, + "schema": { + "type": "string", + "format": "uint64" + } + }, + { + "name": "newName", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1RenameNodeResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/node/{nodeId}/routes": { + "get": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_GetNodeRoutes", + "parameters": [ + { + "name": "nodeId", + "in": "path", + "required": true, + "schema": { + "type": "string", + "format": "uint64" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1GetNodeRoutesResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/node/{nodeId}/tags": { + "post": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_SetTags", + "parameters": [ + { + "name": "nodeId", + "in": "path", + "required": true, + "schema": { + "type": "string", + "format": "uint64" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HeadscaleServiceSetTagsBody" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1SetTagsResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + }, + "x-codegen-request-body-name": "body" + } + }, + "/api/v1/node/{nodeId}/user": { + "post": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_MoveNode", + "parameters": [ + { + "name": "nodeId", + "in": "path", + "required": true, + "schema": { + "type": "string", + "format": "uint64" + } + }, + { + "name": "user", + "in": "query", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1MoveNodeResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/preauthkey": { + "get": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_ListPreAuthKeys", + "parameters": [ + { + "name": "user", + "in": "query", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1ListPreAuthKeysResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + }, + "post": { + "tags": [ + "HeadscaleService" + ], + "summary": "--- PreAuthKeys start ---", + "operationId": "HeadscaleService_CreatePreAuthKey", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1CreatePreAuthKeyRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1CreatePreAuthKeyResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + }, + "x-codegen-request-body-name": "body" + } + }, + "/api/v1/preauthkey/expire": { + "post": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_ExpirePreAuthKey", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1ExpirePreAuthKeyRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1ExpirePreAuthKeyResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + }, + "x-codegen-request-body-name": "body" + } + }, + "/api/v1/routes": { + "get": { + "tags": [ + "HeadscaleService" + ], + "summary": "--- Route start ---", + "operationId": "HeadscaleService_GetRoutes", + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1GetRoutesResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/routes/{routeId}": { + "delete": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_DeleteRoute", + "parameters": [ + { + "name": "routeId", + "in": "path", + "required": true, + "schema": { + "type": "string", + "format": "uint64" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1DeleteRouteResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/routes/{routeId}/disable": { + "post": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_DisableRoute", + "parameters": [ + { + "name": "routeId", + "in": "path", + "required": true, + "schema": { + "type": "string", + "format": "uint64" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1DisableRouteResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/routes/{routeId}/enable": { + "post": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_EnableRoute", + "parameters": [ + { + "name": "routeId", + "in": "path", + "required": true, + "schema": { + "type": "string", + "format": "uint64" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1EnableRouteResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/user": { + "get": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_ListUsers", + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1ListUsersResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + }, + "post": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_CreateUser", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1CreateUserRequest" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1CreateUserResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + }, + "x-codegen-request-body-name": "body" + } + }, + "/api/v1/user/{name}": { + "get": { + "tags": [ + "HeadscaleService" + ], + "summary": "--- User start ---", + "operationId": "HeadscaleService_GetUser", + "parameters": [ + { + "name": "name", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1GetUserResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + }, + "delete": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_DeleteUser", + "parameters": [ + { + "name": "name", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1DeleteUserResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + }, + "/api/v1/user/{oldName}/rename/{newName}": { + "post": { + "tags": [ + "HeadscaleService" + ], + "operationId": "HeadscaleService_RenameUser", + "parameters": [ + { + "name": "oldName", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + }, + { + "name": "newName", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "A successful response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/v1RenameUserResponse" + } + } + } + }, + "default": { + "description": "An unexpected error response.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/rpcStatus" + } + } + } + } + } + } + } + }, + "components": { + "schemas": { + "HeadscaleServiceSetTagsBody": { + "type": "object", + "properties": { + "tags": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "protobufAny": { + "type": "object", + "properties": { + "@type": { + "type": "string" + } + }, + "additionalProperties": { + "type": "object" + } + }, + "rpcStatus": { + "type": "object", + "properties": { + "code": { + "type": "integer", + "format": "int32" + }, + "message": { + "type": "string" + }, + "details": { + "type": "array", + "items": { + "$ref": "#/components/schemas/protobufAny" + } + } + } + }, + "v1ApiKey": { + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "uint64" + }, + "prefix": { + "type": "string" + }, + "expiration": { + "type": "string", + "format": "date-time" + }, + "createdAt": { + "type": "string", + "format": "date-time" + }, + "lastSeen": { + "type": "string", + "format": "date-time" + } + } + }, + "v1BackfillNodeIPsResponse": { + "type": "object", + "properties": { + "changes": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1CreateApiKeyRequest": { + "type": "object", + "properties": { + "expiration": { + "type": "string", + "format": "date-time" + } + } + }, + "v1CreateApiKeyResponse": { + "type": "object", + "properties": { + "apiKey": { + "type": "string" + } + } + }, + "v1CreatePreAuthKeyRequest": { + "type": "object", + "properties": { + "user": { + "type": "string" + }, + "reusable": { + "type": "boolean" + }, + "ephemeral": { + "type": "boolean" + }, + "expiration": { + "type": "string", + "format": "date-time" + }, + "aclTags": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1CreatePreAuthKeyResponse": { + "type": "object", + "properties": { + "preAuthKey": { + "$ref": "#/components/schemas/v1PreAuthKey" + } + } + }, + "v1CreateUserRequest": { + "type": "object", + "properties": { + "name": { + "type": "string" + } + } + }, + "v1CreateUserResponse": { + "type": "object", + "properties": { + "user": { + "$ref": "#/components/schemas/v1User" + } + } + }, + "v1DebugCreateNodeRequest": { + "type": "object", + "properties": { + "user": { + "type": "string" + }, + "key": { + "type": "string" + }, + "name": { + "type": "string" + }, + "routes": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1DebugCreateNodeResponse": { + "type": "object", + "properties": { + "node": { + "$ref": "#/components/schemas/v1Node" + } + } + }, + "v1DeleteApiKeyResponse": { + "type": "object" + }, + "v1DeleteNodeResponse": { + "type": "object" + }, + "v1DeleteRouteResponse": { + "type": "object" + }, + "v1DeleteUserResponse": { + "type": "object" + }, + "v1DisableRouteResponse": { + "type": "object" + }, + "v1EnableRouteResponse": { + "type": "object" + }, + "v1ExpireApiKeyRequest": { + "type": "object", + "properties": { + "prefix": { + "type": "string" + } + } + }, + "v1ExpireApiKeyResponse": { + "type": "object" + }, + "v1ExpireNodeResponse": { + "type": "object", + "properties": { + "node": { + "$ref": "#/components/schemas/v1Node" + } + } + }, + "v1ExpirePreAuthKeyRequest": { + "type": "object", + "properties": { + "user": { + "type": "string" + }, + "key": { + "type": "string" + } + } + }, + "v1ExpirePreAuthKeyResponse": { + "type": "object" + }, + "v1GetNodeResponse": { + "type": "object", + "properties": { + "node": { + "$ref": "#/components/schemas/v1Node" + } + } + }, + "v1GetNodeRoutesResponse": { + "type": "object", + "properties": { + "routes": { + "type": "array", + "items": { + "$ref": "#/components/schemas/v1Route" + } + } + } + }, + "v1GetRoutesResponse": { + "type": "object", + "properties": { + "routes": { + "type": "array", + "items": { + "$ref": "#/components/schemas/v1Route" + } + } + } + }, + "v1GetUserResponse": { + "type": "object", + "properties": { + "user": { + "$ref": "#/components/schemas/v1User" + } + } + }, + "v1ListApiKeysResponse": { + "type": "object", + "properties": { + "apiKeys": { + "type": "array", + "items": { + "$ref": "#/components/schemas/v1ApiKey" + } + } + } + }, + "v1ListNodesResponse": { + "type": "object", + "properties": { + "nodes": { + "type": "array", + "items": { + "$ref": "#/components/schemas/v1Node" + } + } + } + }, + "v1ListPreAuthKeysResponse": { + "type": "object", + "properties": { + "preAuthKeys": { + "type": "array", + "items": { + "$ref": "#/components/schemas/v1PreAuthKey" + } + } + } + }, + "v1ListUsersResponse": { + "type": "object", + "properties": { + "users": { + "type": "array", + "items": { + "$ref": "#/components/schemas/v1User" + } + } + } + }, + "v1MoveNodeResponse": { + "type": "object", + "properties": { + "node": { + "$ref": "#/components/schemas/v1Node" + } + } + }, + "v1Node": { + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "uint64" + }, + "machineKey": { + "type": "string" + }, + "nodeKey": { + "type": "string" + }, + "discoKey": { + "type": "string" + }, + "ipAddresses": { + "type": "array", + "items": { + "type": "string" + } + }, + "name": { + "type": "string" + }, + "user": { + "$ref": "#/components/schemas/v1User" + }, + "lastSeen": { + "type": "string", + "format": "date-time" + }, + "expiry": { + "type": "string", + "format": "date-time" + }, + "preAuthKey": { + "$ref": "#/components/schemas/v1PreAuthKey" + }, + "createdAt": { + "type": "string", + "format": "date-time" + }, + "registerMethod": { + "$ref": "#/components/schemas/v1RegisterMethod" + }, + "forcedTags": { + "type": "array", + "items": { + "type": "string" + } + }, + "invalidTags": { + "type": "array", + "items": { + "type": "string" + } + }, + "validTags": { + "type": "array", + "items": { + "type": "string" + } + }, + "givenName": { + "type": "string" + }, + "online": { + "type": "boolean" + } + } + }, + "v1PreAuthKey": { + "type": "object", + "properties": { + "user": { + "type": "string" + }, + "id": { + "type": "string" + }, + "key": { + "type": "string" + }, + "reusable": { + "type": "boolean" + }, + "ephemeral": { + "type": "boolean" + }, + "used": { + "type": "boolean" + }, + "expiration": { + "type": "string", + "format": "date-time" + }, + "createdAt": { + "type": "string", + "format": "date-time" + }, + "aclTags": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1RegisterMethod": { + "type": "string", + "default": "REGISTER_METHOD_UNSPECIFIED", + "enum": [ + "REGISTER_METHOD_UNSPECIFIED", + "REGISTER_METHOD_AUTH_KEY", + "REGISTER_METHOD_CLI", + "REGISTER_METHOD_OIDC" + ] + }, + "v1RegisterNodeResponse": { + "type": "object", + "properties": { + "node": { + "$ref": "#/components/schemas/v1Node" + } + } + }, + "v1RenameNodeResponse": { + "type": "object", + "properties": { + "node": { + "$ref": "#/components/schemas/v1Node" + } + } + }, + "v1RenameUserResponse": { + "type": "object", + "properties": { + "user": { + "$ref": "#/components/schemas/v1User" + } + } + }, + "v1Route": { + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "uint64" + }, + "node": { + "$ref": "#/components/schemas/v1Node" + }, + "prefix": { + "type": "string" + }, + "advertised": { + "type": "boolean" + }, + "enabled": { + "type": "boolean" + }, + "isPrimary": { + "type": "boolean" + }, + "createdAt": { + "type": "string", + "format": "date-time" + }, + "updatedAt": { + "type": "string", + "format": "date-time" + }, + "deletedAt": { + "type": "string", + "format": "date-time" + } + } + }, + "v1SetTagsResponse": { + "type": "object", + "properties": { + "node": { + "$ref": "#/components/schemas/v1Node" + } + } + }, + "v1User": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "name": { + "type": "string" + }, + "createdAt": { + "type": "string", + "format": "date-time" + } + } + } + } + }, + "x-original-swagger-version": "2.0" +} \ No newline at end of file diff --git a/headscale_api_client/apikeys.py b/headscale_api_client/apikeys.py index d7b3ad7..5336ef4 100644 --- a/headscale_api_client/apikeys.py +++ b/headscale_api_client/apikeys.py @@ -1,26 +1,42 @@ +from pydantic import BaseModel, Field +from typing import Optional, List +from datetime import datetime + from .model import HSAPICall -from headscale_api_client.schemas import (v1CreateApiKeyRequest, - v1ListApiKeysResponse, - v1CreateApiKeyResponse, - v1ExpireApiKeyRequest, - v1ExpireApiKeyResponse, - v1DeleteApiKeyResponse) +from .schemas import v1ApiKey + + +class v1CreateApiKeyRequest(BaseModel): + expiration: str = Field(alias="expiration", default=None) + + +class v1ExpireApiKeyRequest(BaseModel): + prefix: str = Field(alias="prefix", default=None) + + +class v1ListApiKeysResponse(BaseModel): + apiKeys: Optional[List[Optional[v1ApiKey]]] = Field( + alias="apiKeys", default=None) + + +class v1CreateApiKeyResponse(BaseModel): + apiKey: str = Field(alias="apiKey", default=None) class APIKey(HSAPICall): + objectPath = "apikey" + def list(self) -> v1ListApiKeysResponse: - response = self.call('get', 'apikey') + response = self.call('get') return v1ListApiKeysResponse(**response.json()) def create(self, data: v1CreateApiKeyRequest) -> v1CreateApiKeyResponse: - response = self.call('post', 'apikey', data) + response = self.call('post', data=data) return v1CreateApiKeyResponse(**response.json()) - def expire(self, data: v1ExpireApiKeyRequest) -> v1ExpireApiKeyResponse: - response = self.call('post', 'apikey/expire', data) - return v1ExpireApiKeyResponse(**response.json()) + def expire(self, data: v1ExpireApiKeyRequest) -> None: + self.call('post', call_path='expire', data=data) - def delete(self, prefix: str) -> v1DeleteApiKeyResponse: - response = self.call('delete', f'apikey/{prefix}') - return v1DeleteApiKeyResponse(**response.json()) + def delete(self, prefix: str) -> None: + self.call('delete', call_path=prefix) diff --git a/headscale_api_client/model.py b/headscale_api_client/model.py index a99ba62..b393f4c 100644 --- a/headscale_api_client/model.py +++ b/headscale_api_client/model.py @@ -1,15 +1,29 @@ -from .schemas import * +from typing import Union, Optional, Dict, Any from .config import APISettings, HTTPException import requests +def formatTags(tagList: Union[list, None] = []) -> list: + """ + Get a list of tags and prepend `tag:` to all the ones that + do not start with `tag:` + """ + + formattedTags = [] + if tagList: + for tag in tagList: + formatted = f"tag:{tag}" if not tag.startswith('tag:') else tag + formattedTags.append(formatted) + return formattedTags + + class HSAPICall: """ Generic API call. It has a call() method that wants: - a method (GET, POST, DELETE); - - a subpath, that is appended to /api/v1 - - optional `data` payload + - a subpath, that is appended to /api/v1/{self.objectPath} + - optional `data` payload, the body of the request """ objectPath: str = "" @@ -22,7 +36,7 @@ class HSAPICall: self.base_path = f"{ self.api_settings.server}{self.api_settings.api_path}/{self.objectPath}" - def call(self, method, call_path: str = "", data=None): + def call(self, method, call_path: str = "", data=None, query: dict = {}): headers = { "Content-Type": "application/json", "Accept": "application/json", @@ -31,6 +45,10 @@ class HSAPICall: json_ = data.dict() if data else dict() + query_params: Dict[str, Any] = {} + query_params = {key: value for ( + key, value) in query.items() if value is not None} + path = '/'.join([self.base_path, str(call_path)] ) if call_path else self.base_path @@ -38,6 +56,7 @@ class HSAPICall: method, path, headers=headers, + params=query_params, verify=self.api_settings.ssl_verify, json=json_ ) diff --git a/headscale_api_client/nodes.py b/headscale_api_client/nodes.py index 927ba94..d37efd7 100644 --- a/headscale_api_client/nodes.py +++ b/headscale_api_client/nodes.py @@ -1,14 +1,40 @@ -from .model import HSAPICall -from headscale_api_client.schemas import (v1ListNodesResponse, - v1GetNodeResponse, - v1DeleteNodeResponse, - v1ExpireNodeResponse, v1MoveNodeRequest, - v1RenameNodeResponse, - v1MoveNodeRequest, - v1MoveNodeResponse, - v1GetNodeRoutesResponse, - v1SetTagsResponse, - HeadscaleServiceSetTagsBody) +from .model import HSAPICall, formatTags +from .schemas import v1Route, v1Node +from typing import Optional, List +from pydantic import BaseModel, Field + + +class v1SetTagsNodeRequest(BaseModel): + tags: Optional[List[str]] = Field(alias="tags", default=None) + + def model_post_init(self, ctx): + self.tags = formatTags(self.tags) + + +class v1MoveNodeRequest(BaseModel): + user: Optional[str] = Field(alias="user", default=None) + + +class v1BackfillNodeIPsRequest(BaseModel): + confirmed: Optional[bool] = Field(alias="confirmed", default=True) + + +class v1ListNodesResponse(BaseModel): + nodes: Optional[List[Optional[v1Node]]] = Field( + alias="nodes", default=None) + + +class v1NodeResponse(BaseModel): + node: Optional[v1Node] = Field(alias="node", default=None) + + +class v1GetNodeRoutesResponse(BaseModel): + routes: Optional[List[Optional[v1Route]]] = Field( + alias="routes", default=None) + + +class v1BackfillNodeIPsResponse(BaseModel): + changes: Optional[List[str]] = Field(alias="changes", default=None) class Node(HSAPICall): @@ -19,30 +45,34 @@ class Node(HSAPICall): response = self.call('get') return v1ListNodesResponse(**response.json()) - def get(self, nodeId: str) -> v1GetNodeResponse: + def get(self, nodeId: str) -> v1NodeResponse: response = self.call('get', call_path=nodeId) - return v1GetNodeResponse(**response.json()) + return v1NodeResponse(**response.json()) - def delete(self, nodeId: str) -> v1DeleteNodeResponse: - response = self.call('delete', call_path=nodeId) - return v1DeleteNodeResponse(**response.json()) + def delete(self, nodeId: str) -> None: + self.call('delete', call_path=nodeId) - def expire(self, nodeId: str) -> v1ExpireNodeResponse: - response = self.call('post', f'{nodeId}/expire') - return v1ExpireNodeResponse()(**response.json()) + def expire(self, nodeId: str) -> None: + self.call('post', f'{nodeId}/expire') - def rename(self, nodeId: str, newName: str) -> v1RenameNodeResponse: + def rename(self, nodeId: str, newName: str) -> v1NodeResponse: response = self.call('post', f'{nodeId}/rename/{newName}') - return v1RenameNodeResponse(**response.json()) + return v1NodeResponse(**response.json()) - def move(self, nodeId: str, data: v1MoveNodeRequest) -> v1MoveNodeResponse: + def move(self, nodeId: str, data: v1MoveNodeRequest) -> v1NodeResponse: response = self.call('post', f'{nodeId}/user', data) - return v1MoveNodeResponse()(**response.json()) + return v1NodeResponse(**response.json()) def routes(self, nodeId: str) -> v1GetNodeRoutesResponse: response = self.call('get', f'{nodeId}/routes') return v1GetNodeRoutesResponse(**response.json()) - def setTags(self, nodeId: str, data: HeadscaleServiceSetTagsBody) -> v1SetTagsResponse: + def setTags(self, nodeId: str, data: v1SetTagsNodeRequest) -> v1NodeResponse: response = self.call('post', f'{nodeId}/tags', data) - return v1SetTagsResponse(**response.json()) + return v1NodeResponse(**response.json()) + + # Broken on server + def backfillips(self, confirmed: bool = True) -> v1BackfillNodeIPsResponse: + response = self.call( + 'post', f'/backfillips?confirmed={confirmed}') + return v1BackfillNodeIPsResponse(**response.json()) diff --git a/headscale_api_client/preauthkeys.py b/headscale_api_client/preauthkeys.py new file mode 100644 index 0000000..117092f --- /dev/null +++ b/headscale_api_client/preauthkeys.py @@ -0,0 +1,49 @@ +from typing import Optional, List +from pydantic import BaseModel, Field +from .schemas import v1PreAuthKey +from .model import HSAPICall, formatTags + + +class v1ListPreAuthKeysResponse(BaseModel): + preAuthKeys: Optional[List[Optional[v1PreAuthKey]] + ] = Field(alias="preAuthKeys", default=None) + + +class v1PreAuthKeyResponse(BaseModel): + preAuthKey: Optional[v1PreAuthKey] = Field( + alias="preAuthKey", default=None) + + +class v1ExpirePreAuthKeyRequest(BaseModel): + user: str = Field(alias="user", default=None) + key: int = Field(alias="key", default=None) + + +class v1CreatePreAuthKeyRequest(BaseModel): + user: str = Field(alias="user", default=None) + reusable: Optional[bool] = Field(alias="reusable", default=None) + ephemeral: Optional[bool] = Field(alias="ephemeral", default=None) + expiration: Optional[str] = Field(alias="expiration", default=None) + aclTags: Optional[List[str]] = Field(alias="aclTags", default=None) + + +class v1ListPreAuthKeyRequest(BaseModel): + user: Optional[str] = Field( + alias="user", default=None) + + +class PreAuthKey(HSAPICall): + + objectPath = "preauthkey" + + def list(self, data: v1ListPreAuthKeyRequest) -> v1ListPreAuthKeysResponse: + response = self.call('get', query=data.model_dump()) + return v1ListPreAuthKeysResponse(**response.json()) + + def create(self, data: v1CreatePreAuthKeyRequest) -> v1PreAuthKeyResponse: + data.aclTags = formatTags(data.aclTags) + response = self.call('post', data=data) + return v1PreAuthKeyResponse(**response.json()) + + def expire(self, data: v1ExpirePreAuthKeyRequest) -> None: + self.call('post', data=data) diff --git a/headscale_api_client/routes.py b/headscale_api_client/routes.py index 16cc084..145468f 100644 --- a/headscale_api_client/routes.py +++ b/headscale_api_client/routes.py @@ -1,27 +1,27 @@ +from typing import Optional, List +from pydantic import BaseModel, Field from .model import HSAPICall -from headscale_api_client.schemas import (v1GetRoutesResponse, - v1DeleteRouteResponse, - v1EnableRouteResponse, - v1DisableRouteResponse, - ) +from .schemas import v1Route + + +class v1ListRoutesResponse(BaseModel): + routes: Optional[List[Optional[v1Route]]] = Field( + alias="routes", default=None) class Route(HSAPICall): objectPath = "routes" - def list(self) -> v1GetRoutesResponse: + def list(self) -> v1ListRoutesResponse: response = self.call('get') - return v1GetRoutesResponse(**response.json()) + return v1ListRoutesResponse(**response.json()) - def delete(self, routeId: str) -> v1DeleteRouteResponse: - response = self.call('delete', call_path=routeId) - return v1DeleteRouteResponse(**response.json()) + def delete(self, routeId: str) -> None: + self.call('delete', call_path=routeId) - def enable(self, routeId: str) -> v1EnableRouteResponse: - response = self.call('post', f'{routeId}/enable') - return v1EnableRouteResponse(**response.json()) + def enable(self, routeId: str) -> None: + self.call('post', f'{routeId}/enable') - def disable(self, routeId: str) -> v1DisableRouteResponse: - response = self.call('post', f'{routeId}/disable') - return v1DisableRouteResponse(**response.json()) + def disable(self, routeId: str) -> None: + self.call('post', f'{routeId}/disable') diff --git a/headscale_api_client/schemas.py b/headscale_api_client/schemas.py new file mode 100644 index 0000000..025980b --- /dev/null +++ b/headscale_api_client/schemas.py @@ -0,0 +1,101 @@ +from typing import Optional, List +from pydantic import BaseModel, Field, computed_field +from datetime import datetime, timezone, timedelta +from enum import Enum + + +class v1RegisterMethod(str, Enum): + + REGISTER_METHOD_UNSPECIFIED = "REGISTER_METHOD_UNSPECIFIED" + REGISTER_METHOD_AUTH_KEY = "REGISTER_METHOD_AUTH_KEY" + REGISTER_METHOD_CLI = "REGISTER_METHOD_CLI" + REGISTER_METHOD_OIDC = "REGISTER_METHOD_OIDC" + + +class v1ApiKey(BaseModel): + + id: int = Field(alias="id", default=None) + prefix: str = Field(alias="prefix", default=None) + expiration: datetime = Field(alias="expiration", default=None) + createdAt: datetime = Field(alias="createdAt", default=None) + lastSeen: Optional[datetime] = Field(alias="lastSeen", default=None) + + @computed_field + @property + def expired(self) -> bool: + tzinfo = timezone(timedelta(hours=0)) # UTC + now = datetime.now(tzinfo) + return self.expiration < now # type: ignore + + +class v1PreAuthKey(BaseModel): + + id: int = Field(alias="id", default=None) + user: str = Field(alias="user", default=None) + key: str = Field(alias="key", default=None) + reusable: bool = Field(alias="reusable", default=True) + ephemeral: bool = Field(alias="ephemeral", default=False) + used: bool = Field(alias="used", default=None) + expiration: datetime = Field(alias="expiration", default=None) + createdAt: datetime = Field(alias="createdAt", default=None) + aclTags: Optional[List[str]] = Field(alias="aclTags", default=None) + + @computed_field + @property + def expired(self) -> bool: + tzinfo = timezone(timedelta(hours=0)) # UTC + now = datetime.now(tzinfo) + return self.expiration < now # type: ignore + + +class v1User(BaseModel): + + id: int = Field(alias="id", default=None) + name: str = Field(alias="name", default=None) + createdAt: datetime = Field(alias="createdAt", default=None) + + +class v1Node(BaseModel): + """ + None model + + """ + + id: int = Field(alias="id", default=None) + machineKey: str = Field(alias="machineKey", default=None) + nodeKey: str = Field(alias="nodeKey", default=None) + discoKey: str = Field(alias="discoKey", default=None) + ipAddresses: List[str] = Field(alias="ipAddresses", default=None) + name: str = Field(alias="name", default=None) + user: v1User = Field(alias="user", default=None) + lastSeen: datetime = Field(alias="lastSeen", default=None) + expiry: datetime = Field(alias="expiry", default=None) + preAuthKey: Optional[v1PreAuthKey] = Field( + alias="preAuthKey", default=None) + + createdAt: datetime = Field(alias="createdAt", default=None) + registerMethod: Optional[v1RegisterMethod] = Field( + alias="registerMethod", default=None) + + forcedTags: Optional[List[str]] = Field(alias="forcedTags", default=None) + invalidTags: Optional[List[str]] = Field(alias="invalidTags", default=None) + validTags: Optional[List[str]] = Field(alias="validTags", default=None) + givenName: str = Field(alias="givenName", default=None) + online: bool = Field(alias="online", default=None) + + +class v1Route(BaseModel): + """ + None model + + """ + + id: Optional[int] = Field(alias="id", default=None) + node: v1Node = Field(alias="node", default=None) + prefix: str = Field(alias="prefix", default=None) + advertised: bool = Field(alias="advertised", default=None) + enabled: bool = Field(alias="enabled", default=None) + isPrimary: bool = Field(alias="isPrimary", default=None) + createdAt: datetime = Field(alias="createdAt", default=None) + updatedAt: datetime = Field(alias="updatedAt", default=None) + deletedAt: Optional[datetime] = Field(alias="deletedAt", default=None) diff --git a/headscale_api_client/schemas/HeadscaleServiceSetTagsBody.py b/headscale_api_client/schemas/HeadscaleServiceSetTagsBody.py deleted file mode 100644 index c6b1a1a..0000000 --- a/headscale_api_client/schemas/HeadscaleServiceSetTagsBody.py +++ /dev/null @@ -1,12 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class HeadscaleServiceSetTagsBody(BaseModel): - """ - None model - - """ - - tags: Optional[List[str]] = Field(alias="tags", default=None) diff --git a/headscale_api_client/schemas/__init__.py b/headscale_api_client/schemas/__init__.py deleted file mode 100644 index a61c3c1..0000000 --- a/headscale_api_client/schemas/__init__.py +++ /dev/null @@ -1,42 +0,0 @@ -from .HeadscaleServiceSetTagsBody import * -from .protobufAny import * -from .rpcStatus import * -from .v1ApiKey import * -from .v1BackfillNodeIPsResponse import * -from .v1CreateApiKeyRequest import * -from .v1CreateApiKeyResponse import * -from .v1CreatePreAuthKeyRequest import * -from .v1CreatePreAuthKeyResponse import * -from .v1CreateUserRequest import * -from .v1CreateUserResponse import * -from .v1DebugCreateNodeRequest import * -from .v1DebugCreateNodeResponse import * -from .v1DeleteApiKeyResponse import * -from .v1DeleteNodeResponse import * -from .v1DeleteRouteResponse import * -from .v1DeleteUserResponse import * -from .v1DisableRouteResponse import * -from .v1EnableRouteResponse import * -from .v1ExpireApiKeyRequest import * -from .v1ExpireApiKeyResponse import * -from .v1ExpireNodeResponse import * -from .v1ExpirePreAuthKeyRequest import * -from .v1ExpirePreAuthKeyResponse import * -from .v1GetNodeResponse import * -from .v1GetNodeRoutesResponse import * -from .v1GetRoutesResponse import * -from .v1GetUserResponse import * -from .v1ListApiKeysResponse import * -from .v1ListNodesResponse import * -from .v1ListPreAuthKeysResponse import * -from .v1ListUsersResponse import * -from .v1MoveNodeResponse import * -from .v1Node import * -from .v1PreAuthKey import * -from .v1RegisterMethod import * -from .v1RegisterNodeResponse import * -from .v1RenameNodeResponse import * -from .v1RenameUserResponse import * -from .v1Route import * -from .v1SetTagsResponse import * -from .v1User import * diff --git a/headscale_api_client/schemas/protobufAny.py b/headscale_api_client/schemas/protobufAny.py deleted file mode 100644 index bcc0bd6..0000000 --- a/headscale_api_client/schemas/protobufAny.py +++ /dev/null @@ -1,12 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class protobufAny(BaseModel): - """ - None model - - """ - - type: Optional[str] = Field(alias="@type", default=None) diff --git a/headscale_api_client/schemas/rpcStatus.py b/headscale_api_client/schemas/rpcStatus.py deleted file mode 100644 index e34a872..0000000 --- a/headscale_api_client/schemas/rpcStatus.py +++ /dev/null @@ -1,18 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .protobufAny import protobufAny - - -class rpcStatus(BaseModel): - """ - None model - - """ - - code: Optional[int] = Field(alias="code", default=None) - - message: Optional[str] = Field(alias="message", default=None) - - details: Optional[List[Optional[protobufAny]]] = Field(alias="details", default=None) diff --git a/headscale_api_client/schemas/v1ApiKey.py b/headscale_api_client/schemas/v1ApiKey.py deleted file mode 100644 index 7235d50..0000000 --- a/headscale_api_client/schemas/v1ApiKey.py +++ /dev/null @@ -1,20 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1ApiKey(BaseModel): - """ - None model - - """ - - id: Optional[str] = Field(alias="id", default=None) - - prefix: Optional[str] = Field(alias="prefix", default=None) - - expiration: Optional[str] = Field(alias="expiration", default=None) - - createdAt: Optional[str] = Field(alias="createdAt", default=None) - - lastSeen: Optional[str] = Field(alias="lastSeen", default=None) diff --git a/headscale_api_client/schemas/v1BackfillNodeIPsResponse.py b/headscale_api_client/schemas/v1BackfillNodeIPsResponse.py deleted file mode 100644 index c20348d..0000000 --- a/headscale_api_client/schemas/v1BackfillNodeIPsResponse.py +++ /dev/null @@ -1,12 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1BackfillNodeIPsResponse(BaseModel): - """ - None model - - """ - - changes: Optional[List[str]] = Field(alias="changes", default=None) diff --git a/headscale_api_client/schemas/v1CreateApiKeyRequest.py b/headscale_api_client/schemas/v1CreateApiKeyRequest.py deleted file mode 100644 index 51c74ad..0000000 --- a/headscale_api_client/schemas/v1CreateApiKeyRequest.py +++ /dev/null @@ -1,12 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1CreateApiKeyRequest(BaseModel): - """ - None model - - """ - - expiration: Optional[str] = Field(alias="expiration", default=None) diff --git a/headscale_api_client/schemas/v1CreateApiKeyResponse.py b/headscale_api_client/schemas/v1CreateApiKeyResponse.py deleted file mode 100644 index 95709e8..0000000 --- a/headscale_api_client/schemas/v1CreateApiKeyResponse.py +++ /dev/null @@ -1,12 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1CreateApiKeyResponse(BaseModel): - """ - None model - - """ - - apiKey: Optional[str] = Field(alias="apiKey", default=None) diff --git a/headscale_api_client/schemas/v1CreatePreAuthKeyRequest.py b/headscale_api_client/schemas/v1CreatePreAuthKeyRequest.py deleted file mode 100644 index 394dcb6..0000000 --- a/headscale_api_client/schemas/v1CreatePreAuthKeyRequest.py +++ /dev/null @@ -1,20 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1CreatePreAuthKeyRequest(BaseModel): - """ - None model - - """ - - user: Optional[str] = Field(alias="user", default=None) - - reusable: Optional[bool] = Field(alias="reusable", default=None) - - ephemeral: Optional[bool] = Field(alias="ephemeral", default=None) - - expiration: Optional[str] = Field(alias="expiration", default=None) - - aclTags: Optional[List[str]] = Field(alias="aclTags", default=None) diff --git a/headscale_api_client/schemas/v1CreatePreAuthKeyResponse.py b/headscale_api_client/schemas/v1CreatePreAuthKeyResponse.py deleted file mode 100644 index 3a962f1..0000000 --- a/headscale_api_client/schemas/v1CreatePreAuthKeyResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1PreAuthKey import v1PreAuthKey - - -class v1CreatePreAuthKeyResponse(BaseModel): - """ - None model - - """ - - preAuthKey: Optional[v1PreAuthKey] = Field(alias="preAuthKey", default=None) diff --git a/headscale_api_client/schemas/v1CreateUserRequest.py b/headscale_api_client/schemas/v1CreateUserRequest.py deleted file mode 100644 index 919dda1..0000000 --- a/headscale_api_client/schemas/v1CreateUserRequest.py +++ /dev/null @@ -1,12 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1CreateUserRequest(BaseModel): - """ - None model - - """ - - name: Optional[str] = Field(alias="name", default=None) diff --git a/headscale_api_client/schemas/v1CreateUserResponse.py b/headscale_api_client/schemas/v1CreateUserResponse.py deleted file mode 100644 index bf890dd..0000000 --- a/headscale_api_client/schemas/v1CreateUserResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1User import v1User - - -class v1CreateUserResponse(BaseModel): - """ - None model - - """ - - user: Optional[v1User] = Field(alias="user", default=None) diff --git a/headscale_api_client/schemas/v1DebugCreateNodeRequest.py b/headscale_api_client/schemas/v1DebugCreateNodeRequest.py deleted file mode 100644 index 48792f3..0000000 --- a/headscale_api_client/schemas/v1DebugCreateNodeRequest.py +++ /dev/null @@ -1,18 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1DebugCreateNodeRequest(BaseModel): - """ - None model - - """ - - user: Optional[str] = Field(alias="user", default=None) - - key: Optional[str] = Field(alias="key", default=None) - - name: Optional[str] = Field(alias="name", default=None) - - routes: Optional[List[str]] = Field(alias="routes", default=None) diff --git a/headscale_api_client/schemas/v1DebugCreateNodeResponse.py b/headscale_api_client/schemas/v1DebugCreateNodeResponse.py deleted file mode 100644 index 1d0ca31..0000000 --- a/headscale_api_client/schemas/v1DebugCreateNodeResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1Node import v1Node - - -class v1DebugCreateNodeResponse(BaseModel): - """ - None model - - """ - - node: Optional[v1Node] = Field(alias="node", default=None) diff --git a/headscale_api_client/schemas/v1DeleteApiKeyResponse.py b/headscale_api_client/schemas/v1DeleteApiKeyResponse.py deleted file mode 100644 index eb0a7bc..0000000 --- a/headscale_api_client/schemas/v1DeleteApiKeyResponse.py +++ /dev/null @@ -1,10 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1DeleteApiKeyResponse(BaseModel): - """ - None model - - """ diff --git a/headscale_api_client/schemas/v1DeleteNodeResponse.py b/headscale_api_client/schemas/v1DeleteNodeResponse.py deleted file mode 100644 index 9e25b10..0000000 --- a/headscale_api_client/schemas/v1DeleteNodeResponse.py +++ /dev/null @@ -1,10 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1DeleteNodeResponse(BaseModel): - """ - None model - - """ diff --git a/headscale_api_client/schemas/v1DeleteRouteResponse.py b/headscale_api_client/schemas/v1DeleteRouteResponse.py deleted file mode 100644 index 7b333ce..0000000 --- a/headscale_api_client/schemas/v1DeleteRouteResponse.py +++ /dev/null @@ -1,10 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1DeleteRouteResponse(BaseModel): - """ - None model - - """ diff --git a/headscale_api_client/schemas/v1DeleteUserResponse.py b/headscale_api_client/schemas/v1DeleteUserResponse.py deleted file mode 100644 index e8b63cb..0000000 --- a/headscale_api_client/schemas/v1DeleteUserResponse.py +++ /dev/null @@ -1,10 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1DeleteUserResponse(BaseModel): - """ - None model - - """ diff --git a/headscale_api_client/schemas/v1DisableRouteResponse.py b/headscale_api_client/schemas/v1DisableRouteResponse.py deleted file mode 100644 index 0401cfc..0000000 --- a/headscale_api_client/schemas/v1DisableRouteResponse.py +++ /dev/null @@ -1,10 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1DisableRouteResponse(BaseModel): - """ - None model - - """ diff --git a/headscale_api_client/schemas/v1EnableRouteResponse.py b/headscale_api_client/schemas/v1EnableRouteResponse.py deleted file mode 100644 index b7a7586..0000000 --- a/headscale_api_client/schemas/v1EnableRouteResponse.py +++ /dev/null @@ -1,10 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1EnableRouteResponse(BaseModel): - """ - None model - - """ diff --git a/headscale_api_client/schemas/v1ExpireApiKeyRequest.py b/headscale_api_client/schemas/v1ExpireApiKeyRequest.py deleted file mode 100644 index 43ae93d..0000000 --- a/headscale_api_client/schemas/v1ExpireApiKeyRequest.py +++ /dev/null @@ -1,12 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1ExpireApiKeyRequest(BaseModel): - """ - None model - - """ - - prefix: Optional[str] = Field(alias="prefix", default=None) diff --git a/headscale_api_client/schemas/v1ExpireApiKeyResponse.py b/headscale_api_client/schemas/v1ExpireApiKeyResponse.py deleted file mode 100644 index 4d8b72e..0000000 --- a/headscale_api_client/schemas/v1ExpireApiKeyResponse.py +++ /dev/null @@ -1,10 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1ExpireApiKeyResponse(BaseModel): - """ - None model - - """ diff --git a/headscale_api_client/schemas/v1ExpireNodeResponse.py b/headscale_api_client/schemas/v1ExpireNodeResponse.py deleted file mode 100644 index 16eb7f2..0000000 --- a/headscale_api_client/schemas/v1ExpireNodeResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1Node import v1Node - - -class v1ExpireNodeResponse(BaseModel): - """ - None model - - """ - - node: Optional[v1Node] = Field(alias="node", default=None) diff --git a/headscale_api_client/schemas/v1ExpirePreAuthKeyRequest.py b/headscale_api_client/schemas/v1ExpirePreAuthKeyRequest.py deleted file mode 100644 index 2e401d8..0000000 --- a/headscale_api_client/schemas/v1ExpirePreAuthKeyRequest.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1ExpirePreAuthKeyRequest(BaseModel): - """ - None model - - """ - - user: Optional[str] = Field(alias="user", default=None) - - key: Optional[str] = Field(alias="key", default=None) diff --git a/headscale_api_client/schemas/v1ExpirePreAuthKeyResponse.py b/headscale_api_client/schemas/v1ExpirePreAuthKeyResponse.py deleted file mode 100644 index af44c0f..0000000 --- a/headscale_api_client/schemas/v1ExpirePreAuthKeyResponse.py +++ /dev/null @@ -1,10 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1ExpirePreAuthKeyResponse(BaseModel): - """ - None model - - """ diff --git a/headscale_api_client/schemas/v1GetNodeResponse.py b/headscale_api_client/schemas/v1GetNodeResponse.py deleted file mode 100644 index adfeb17..0000000 --- a/headscale_api_client/schemas/v1GetNodeResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1Node import v1Node - - -class v1GetNodeResponse(BaseModel): - """ - None model - - """ - - node: Optional[v1Node] = Field(alias="node", default=None) diff --git a/headscale_api_client/schemas/v1GetNodeRoutesResponse.py b/headscale_api_client/schemas/v1GetNodeRoutesResponse.py deleted file mode 100644 index f48cf40..0000000 --- a/headscale_api_client/schemas/v1GetNodeRoutesResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1Route import v1Route - - -class v1GetNodeRoutesResponse(BaseModel): - """ - None model - - """ - - routes: Optional[List[Optional[v1Route]]] = Field(alias="routes", default=None) diff --git a/headscale_api_client/schemas/v1GetRoutesResponse.py b/headscale_api_client/schemas/v1GetRoutesResponse.py deleted file mode 100644 index 997b67b..0000000 --- a/headscale_api_client/schemas/v1GetRoutesResponse.py +++ /dev/null @@ -1,15 +0,0 @@ -from typing import Optional, List - -from pydantic import BaseModel, Field - -from .v1Route import v1Route - - -class v1GetRoutesResponse(BaseModel): - """ - None model - - """ - - routes: Optional[List[Optional[v1Route]]] = Field( - alias="routes", default=None) diff --git a/headscale_api_client/schemas/v1GetUserResponse.py b/headscale_api_client/schemas/v1GetUserResponse.py deleted file mode 100644 index a523b2d..0000000 --- a/headscale_api_client/schemas/v1GetUserResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1User import v1User - - -class v1GetUserResponse(BaseModel): - """ - None model - - """ - - user: Optional[v1User] = Field(alias="user", default=None) diff --git a/headscale_api_client/schemas/v1ListApiKeysResponse.py b/headscale_api_client/schemas/v1ListApiKeysResponse.py deleted file mode 100644 index 470be2a..0000000 --- a/headscale_api_client/schemas/v1ListApiKeysResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1ApiKey import v1ApiKey - - -class v1ListApiKeysResponse(BaseModel): - """ - None model - - """ - - apiKeys: Optional[List[Optional[v1ApiKey]]] = Field(alias="apiKeys", default=None) diff --git a/headscale_api_client/schemas/v1ListNodesResponse.py b/headscale_api_client/schemas/v1ListNodesResponse.py deleted file mode 100644 index 33b321b..0000000 --- a/headscale_api_client/schemas/v1ListNodesResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1Node import v1Node - - -class v1ListNodesResponse(BaseModel): - """ - None model - - """ - - nodes: Optional[List[Optional[v1Node]]] = Field(alias="nodes", default=None) diff --git a/headscale_api_client/schemas/v1ListPreAuthKeysResponse.py b/headscale_api_client/schemas/v1ListPreAuthKeysResponse.py deleted file mode 100644 index 0a71756..0000000 --- a/headscale_api_client/schemas/v1ListPreAuthKeysResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1PreAuthKey import v1PreAuthKey - - -class v1ListPreAuthKeysResponse(BaseModel): - """ - None model - - """ - - preAuthKeys: Optional[List[Optional[v1PreAuthKey]]] = Field(alias="preAuthKeys", default=None) diff --git a/headscale_api_client/schemas/v1ListUsersResponse.py b/headscale_api_client/schemas/v1ListUsersResponse.py deleted file mode 100644 index be8d830..0000000 --- a/headscale_api_client/schemas/v1ListUsersResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1User import v1User - - -class v1ListUsersResponse(BaseModel): - """ - None model - - """ - - users: Optional[List[Optional[v1User]]] = Field(alias="users", default=None) diff --git a/headscale_api_client/schemas/v1MoveNodeRequest.py b/headscale_api_client/schemas/v1MoveNodeRequest.py deleted file mode 100644 index b8b02b1..0000000 --- a/headscale_api_client/schemas/v1MoveNodeRequest.py +++ /dev/null @@ -1,12 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1DebugCreateNodeRequest(BaseModel): - """ - None model - - """ - - user: Optional[str] = Field(alias="user", default=None) diff --git a/headscale_api_client/schemas/v1MoveNodeResponse.py b/headscale_api_client/schemas/v1MoveNodeResponse.py deleted file mode 100644 index 37390d4..0000000 --- a/headscale_api_client/schemas/v1MoveNodeResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1Node import v1Node - - -class v1MoveNodeResponse(BaseModel): - """ - None model - - """ - - node: Optional[v1Node] = Field(alias="node", default=None) diff --git a/headscale_api_client/schemas/v1Node.py b/headscale_api_client/schemas/v1Node.py deleted file mode 100644 index e8bc4ee..0000000 --- a/headscale_api_client/schemas/v1Node.py +++ /dev/null @@ -1,36 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1PreAuthKey import v1PreAuthKey -from .v1RegisterMethod import v1RegisterMethod -from .v1User import v1User - - -class v1Node(BaseModel): - """ - None model - - """ - - id: Optional[int] = Field(alias="id", default=None) - machineKey: Optional[str] = Field(alias="machineKey", default=None) - nodeKey: Optional[str] = Field(alias="nodeKey", default=None) - discoKey: Optional[str] = Field(alias="discoKey", default=None) - ipAddresses: Optional[List[str]] = Field(alias="ipAddresses", default=None) - name: Optional[str] = Field(alias="name", default=None) - user: Optional[v1User] = Field(alias="user", default=None) - lastSeen: Optional[str] = Field(alias="lastSeen", default=None) - expiry: Optional[str] = Field(alias="expiry", default=None) - preAuthKey: Optional[v1PreAuthKey] = Field( - alias="preAuthKey", default=None) - - createdAt: Optional[str] = Field(alias="createdAt", default=None) - registerMethod: Optional[v1RegisterMethod] = Field( - alias="registerMethod", default=None) - - forcedTags: Optional[List[str]] = Field(alias="forcedTags", default=None) - invalidTags: Optional[List[str]] = Field(alias="invalidTags", default=None) - validTags: Optional[List[str]] = Field(alias="validTags", default=None) - givenName: Optional[str] = Field(alias="givenName", default=None) - online: Optional[bool] = Field(alias="online", default=None) diff --git a/headscale_api_client/schemas/v1PreAuthKey.py b/headscale_api_client/schemas/v1PreAuthKey.py deleted file mode 100644 index 57a8b27..0000000 --- a/headscale_api_client/schemas/v1PreAuthKey.py +++ /dev/null @@ -1,28 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1PreAuthKey(BaseModel): - """ - None model - - """ - - user: Optional[str] = Field(alias="user", default=None) - - id: Optional[str] = Field(alias="id", default=None) - - key: Optional[str] = Field(alias="key", default=None) - - reusable: Optional[bool] = Field(alias="reusable", default=None) - - ephemeral: Optional[bool] = Field(alias="ephemeral", default=None) - - used: Optional[bool] = Field(alias="used", default=None) - - expiration: Optional[str] = Field(alias="expiration", default=None) - - createdAt: Optional[str] = Field(alias="createdAt", default=None) - - aclTags: Optional[List[str]] = Field(alias="aclTags", default=None) diff --git a/headscale_api_client/schemas/v1RegisterMethod.py b/headscale_api_client/schemas/v1RegisterMethod.py deleted file mode 100644 index c812382..0000000 --- a/headscale_api_client/schemas/v1RegisterMethod.py +++ /dev/null @@ -1,9 +0,0 @@ -from enum import Enum - - -class v1RegisterMethod(str, Enum): - - REGISTER_METHOD_UNSPECIFIED = "REGISTER_METHOD_UNSPECIFIED" - REGISTER_METHOD_AUTH_KEY = "REGISTER_METHOD_AUTH_KEY" - REGISTER_METHOD_CLI = "REGISTER_METHOD_CLI" - REGISTER_METHOD_OIDC = "REGISTER_METHOD_OIDC" diff --git a/headscale_api_client/schemas/v1RegisterNodeResponse.py b/headscale_api_client/schemas/v1RegisterNodeResponse.py deleted file mode 100644 index 0ee8719..0000000 --- a/headscale_api_client/schemas/v1RegisterNodeResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1Node import v1Node - - -class v1RegisterNodeResponse(BaseModel): - """ - None model - - """ - - node: Optional[v1Node] = Field(alias="node", default=None) diff --git a/headscale_api_client/schemas/v1RenameNodeResponse.py b/headscale_api_client/schemas/v1RenameNodeResponse.py deleted file mode 100644 index a5b57b0..0000000 --- a/headscale_api_client/schemas/v1RenameNodeResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1Node import v1Node - - -class v1RenameNodeResponse(BaseModel): - """ - None model - - """ - - node: Optional[v1Node] = Field(alias="node", default=None) diff --git a/headscale_api_client/schemas/v1RenameUserResponse.py b/headscale_api_client/schemas/v1RenameUserResponse.py deleted file mode 100644 index 1e223e3..0000000 --- a/headscale_api_client/schemas/v1RenameUserResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1User import v1User - - -class v1RenameUserResponse(BaseModel): - """ - None model - - """ - - user: Optional[v1User] = Field(alias="user", default=None) diff --git a/headscale_api_client/schemas/v1Route.py b/headscale_api_client/schemas/v1Route.py deleted file mode 100644 index afa9c05..0000000 --- a/headscale_api_client/schemas/v1Route.py +++ /dev/null @@ -1,22 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1Node import v1Node - - -class v1Route(BaseModel): - """ - None model - - """ - - id: Optional[int] = Field(alias="id", default=None) - node: Optional[v1Node] = Field(alias="node", default=None) - prefix: Optional[str] = Field(alias="prefix", default=None) - advertised: Optional[bool] = Field(alias="advertised", default=None) - enabled: Optional[bool] = Field(alias="enabled", default=None) - isPrimary: Optional[bool] = Field(alias="isPrimary", default=None) - createdAt: Optional[str] = Field(alias="createdAt", default=None) - updatedAt: Optional[str] = Field(alias="updatedAt", default=None) - deletedAt: Optional[str] = Field(alias="deletedAt", default=None) diff --git a/headscale_api_client/schemas/v1SetTagsResponse.py b/headscale_api_client/schemas/v1SetTagsResponse.py deleted file mode 100644 index be86320..0000000 --- a/headscale_api_client/schemas/v1SetTagsResponse.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - -from .v1Node import v1Node - - -class v1SetTagsResponse(BaseModel): - """ - None model - - """ - - node: Optional[v1Node] = Field(alias="node", default=None) diff --git a/headscale_api_client/schemas/v1User.py b/headscale_api_client/schemas/v1User.py deleted file mode 100644 index d0405b9..0000000 --- a/headscale_api_client/schemas/v1User.py +++ /dev/null @@ -1,14 +0,0 @@ -from typing import * - -from pydantic import BaseModel, Field - - -class v1User(BaseModel): - """ - None model - - """ - - id: Optional[int] = Field(alias="id", default=None) - name: Optional[str] = Field(alias="name", default=None) - createdAt: Optional[str] = Field(alias="createdAt", default=None) diff --git a/headscale_api_client/users.py b/headscale_api_client/users.py index 5caae4c..341152d 100644 --- a/headscale_api_client/users.py +++ b/headscale_api_client/users.py @@ -1,11 +1,20 @@ +from typing import Optional, List +from pydantic import BaseModel, Field +from .schemas import v1User from .model import HSAPICall -from headscale_api_client.schemas import (v1CreateUserRequest, - v1CreateUserResponse, - v1DeleteUserResponse, - v1ListUsersResponse, - v1GetUserResponse, - v1RenameUserResponse, - ) + + +class v1CreateUserRequest(BaseModel): + name: str = Field(alias="name", default=None) + + +class v1ListUsersResponse(BaseModel): + users: Optional[List[Optional[v1User]]] = Field( + alias="users", default=None) + + +class v1UserResponse(BaseModel): + user: Optional[v1User] = Field(alias="user", default=None) class User(HSAPICall): @@ -16,18 +25,17 @@ class User(HSAPICall): response = self.call('get') return v1ListUsersResponse(**response.json()) - def get(self, name: str) -> v1GetUserResponse: + def get(self, name: str) -> v1UserResponse: response = self.call('get', call_path=name) - return v1GetUserResponse(**response.json()) + return v1UserResponse(**response.json()) - def create(self, data: v1CreateUserRequest) -> v1CreateUserResponse: + def create(self, data: v1CreateUserRequest) -> v1UserResponse: response = self.call('post', data=data) - return v1CreateUserResponse(**response.json()) + return v1UserResponse(**response.json()) - def delete(self, name: str) -> v1DeleteUserResponse: - response = self.call('delete', name) - return v1DeleteUserResponse(**response.json()) + def delete(self, name: str) -> None: + self.call('delete', name) - def rename(self, oldName: str, newName: str) -> v1RenameUserResponse: + def rename(self, oldName: str, newName: str) -> v1UserResponse: response = self.call('post', call_path=f"{oldName}/rename/{newName}") - return v1RenameUserResponse(**response.json()) + return v1UserResponse(**response.json())