diff --git a/api-docs/openapi.json b/api-docs/openapi.json index eea4c3c5..38c8aec4 100644 --- a/api-docs/openapi.json +++ b/api-docs/openapi.json @@ -4,7 +4,7 @@ "description": "REST API for Cosmos Cloud server management", "title": "Cosmos Server API", "contact": {}, - "version": "0.22.13" + "version": "0.22.14" }, "paths": { "/_logs": { @@ -2196,6 +2196,305 @@ } } }, + "/api/constellation/deployments": { + "get": { + "security": [ + { + "BearerAuth": [] + } + ], + "description": "Returns all deployment definitions from the constellation-deployments KV (Pro feature)", + "tags": [ + "deployments" + ], + "summary": "List all cluster deployments", + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.APIResponse" + } + } + } + }, + "401": { + "description": "Unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.HTTPErrorResult" + } + } + } + }, + "403": { + "description": "Forbidden", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.HTTPErrorResult" + } + } + } + } + } + }, + "post": { + "security": [ + { + "BearerAuth": [] + } + ], + "description": "Creates a new deployment definition in the constellation-deployments KV (Pro feature)", + "tags": [ + "deployments" + ], + "summary": "Create a new cluster deployment", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/pro.Deployment" + } + } + }, + "description": "Deployment definition", + "required": true + }, + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.APIResponse" + } + } + } + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.HTTPErrorResult" + } + } + } + }, + "401": { + "description": "Unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.HTTPErrorResult" + } + } + } + }, + "409": { + "description": "Conflict", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.HTTPErrorResult" + } + } + } + } + } + } + }, + "/api/constellation/deployments/{name}": { + "get": { + "security": [ + { + "BearerAuth": [] + } + ], + "description": "Returns a single deployment definition (Pro feature)", + "tags": [ + "deployments" + ], + "summary": "Get a cluster deployment by name", + "parameters": [ + { + "description": "Deployment name", + "name": "name", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.APIResponse" + } + } + } + }, + "401": { + "description": "Unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.HTTPErrorResult" + } + } + } + }, + "404": { + "description": "Not Found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.HTTPErrorResult" + } + } + } + } + } + }, + "put": { + "security": [ + { + "BearerAuth": [] + } + ], + "description": "Updates an existing deployment definition (Pro feature)", + "tags": [ + "deployments" + ], + "summary": "Update a cluster deployment", + "parameters": [ + { + "description": "Deployment name", + "name": "name", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/pro.Deployment" + } + } + }, + "description": "Updated deployment", + "required": true + }, + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.APIResponse" + } + } + } + }, + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.HTTPErrorResult" + } + } + } + }, + "401": { + "description": "Unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.HTTPErrorResult" + } + } + } + }, + "404": { + "description": "Not Found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.HTTPErrorResult" + } + } + } + } + } + }, + "delete": { + "security": [ + { + "BearerAuth": [] + } + ], + "description": "Removes a deployment from the constellation-deployments KV (Pro feature)", + "tags": [ + "deployments" + ], + "summary": "Delete a cluster deployment", + "parameters": [ + { + "description": "Deployment name", + "name": "name", + "in": "path", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.APIResponse" + } + } + } + }, + "401": { + "description": "Unauthorized", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.HTTPErrorResult" + } + } + } + }, + "404": { + "description": "Not Found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/utils.HTTPErrorResult" + } + } + } + } + } + } + }, "/api/constellation/devices": { "get": { "security": [ @@ -11413,6 +11712,50 @@ } } }, + "pro.Deployment": { + "type": "object", + "required": [ + "compose", + "name", + "replicas" + ], + "properties": { + "compose": { + "$ref": "#/components/schemas/docker.DockerServiceCreateRequest" + }, + "name": { + "type": "string", + "maxLength": 64, + "minLength": 3 + }, + "replicas": { + "type": "integer", + "minimum": 1 + }, + "storage": { + "description": "Storage lists RCLONE remote names this deployment depends on. Checked\nnode-side in executeApply before docker.CreateService runs — a missing\nremote produces StatusFail and flows through the existing fail-streak\nquarantine path. Not a placement filter: RCLONE config is cluster-synced\nvia constellation, so every eligible node has the same remote set.\n${storage.NAME} in compose fields resolves to the mount path on apply.", + "type": "array", + "items": { + "type": "string" + } + }, + "strategy": { + "description": "Strategy selects which PlacementStrategy the scheduler uses for this\ndeployment. Empty is treated as \"round-robin\" for back-compat with\nKV entries written before this field existed.", + "type": "string", + "enum": [ + "round-robin", + "least-busy" + ] + }, + "tags": { + "description": "Tags filter eligible placement nodes. A deployment with Tags=[\"gpu\"]\nwill only land on nodes whose ConstellationDevice.Tags contains \"gpu\".\nMultiple tags are AND'd: [\"gpu\",\"nvme\"] requires both. Empty means no\nfilter — any node is eligible.", + "type": "array", + "items": { + "type": "string" + } + } + } + }, "pro.UpdateGroupRequest": { "type": "object", "properties": { diff --git a/api-docs/swagger.json b/api-docs/swagger.json index d2bc4b6b..ee7497a1 100644 --- a/api-docs/swagger.json +++ b/api-docs/swagger.json @@ -4,7 +4,7 @@ "description": "REST API for Cosmos Cloud server management", "title": "Cosmos Server API", "contact": {}, - "version": "0.22.13" + "version": "0.22.14" }, "basePath": "/cosmos", "paths": { @@ -1812,6 +1812,250 @@ } } }, + "/api/constellation/deployments": { + "get": { + "security": [ + { + "BearerAuth": [] + } + ], + "description": "Returns all deployment definitions from the constellation-deployments KV (Pro feature)", + "produces": [ + "application/json" + ], + "tags": [ + "deployments" + ], + "summary": "List all cluster deployments", + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/utils.APIResponse" + } + }, + "401": { + "description": "Unauthorized", + "schema": { + "$ref": "#/definitions/utils.HTTPErrorResult" + } + }, + "403": { + "description": "Forbidden", + "schema": { + "$ref": "#/definitions/utils.HTTPErrorResult" + } + } + } + }, + "post": { + "security": [ + { + "BearerAuth": [] + } + ], + "description": "Creates a new deployment definition in the constellation-deployments KV (Pro feature)", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "deployments" + ], + "summary": "Create a new cluster deployment", + "parameters": [ + { + "description": "Deployment definition", + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/pro.Deployment" + } + } + ], + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/utils.APIResponse" + } + }, + "400": { + "description": "Bad Request", + "schema": { + "$ref": "#/definitions/utils.HTTPErrorResult" + } + }, + "401": { + "description": "Unauthorized", + "schema": { + "$ref": "#/definitions/utils.HTTPErrorResult" + } + }, + "409": { + "description": "Conflict", + "schema": { + "$ref": "#/definitions/utils.HTTPErrorResult" + } + } + } + } + }, + "/api/constellation/deployments/{name}": { + "get": { + "security": [ + { + "BearerAuth": [] + } + ], + "description": "Returns a single deployment definition (Pro feature)", + "produces": [ + "application/json" + ], + "tags": [ + "deployments" + ], + "summary": "Get a cluster deployment by name", + "parameters": [ + { + "type": "string", + "description": "Deployment name", + "name": "name", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/utils.APIResponse" + } + }, + "401": { + "description": "Unauthorized", + "schema": { + "$ref": "#/definitions/utils.HTTPErrorResult" + } + }, + "404": { + "description": "Not Found", + "schema": { + "$ref": "#/definitions/utils.HTTPErrorResult" + } + } + } + }, + "put": { + "security": [ + { + "BearerAuth": [] + } + ], + "description": "Updates an existing deployment definition (Pro feature)", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "deployments" + ], + "summary": "Update a cluster deployment", + "parameters": [ + { + "type": "string", + "description": "Deployment name", + "name": "name", + "in": "path", + "required": true + }, + { + "description": "Updated deployment", + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/pro.Deployment" + } + } + ], + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/utils.APIResponse" + } + }, + "400": { + "description": "Bad Request", + "schema": { + "$ref": "#/definitions/utils.HTTPErrorResult" + } + }, + "401": { + "description": "Unauthorized", + "schema": { + "$ref": "#/definitions/utils.HTTPErrorResult" + } + }, + "404": { + "description": "Not Found", + "schema": { + "$ref": "#/definitions/utils.HTTPErrorResult" + } + } + } + }, + "delete": { + "security": [ + { + "BearerAuth": [] + } + ], + "description": "Removes a deployment from the constellation-deployments KV (Pro feature)", + "produces": [ + "application/json" + ], + "tags": [ + "deployments" + ], + "summary": "Delete a cluster deployment", + "parameters": [ + { + "type": "string", + "description": "Deployment name", + "name": "name", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/utils.APIResponse" + } + }, + "401": { + "description": "Unauthorized", + "schema": { + "$ref": "#/definitions/utils.HTTPErrorResult" + } + }, + "404": { + "description": "Not Found", + "schema": { + "$ref": "#/definitions/utils.HTTPErrorResult" + } + } + } + } + }, "/api/constellation/devices": { "get": { "security": [ @@ -9660,6 +9904,50 @@ } } }, + "pro.Deployment": { + "type": "object", + "required": [ + "compose", + "name", + "replicas" + ], + "properties": { + "compose": { + "$ref": "#/definitions/docker.DockerServiceCreateRequest" + }, + "name": { + "type": "string", + "maxLength": 64, + "minLength": 3 + }, + "replicas": { + "type": "integer", + "minimum": 1 + }, + "storage": { + "description": "Storage lists RCLONE remote names this deployment depends on. Checked\nnode-side in executeApply before docker.CreateService runs — a missing\nremote produces StatusFail and flows through the existing fail-streak\nquarantine path. Not a placement filter: RCLONE config is cluster-synced\nvia constellation, so every eligible node has the same remote set.\n${storage.NAME} in compose fields resolves to the mount path on apply.", + "type": "array", + "items": { + "type": "string" + } + }, + "strategy": { + "description": "Strategy selects which PlacementStrategy the scheduler uses for this\ndeployment. Empty is treated as \"round-robin\" for back-compat with\nKV entries written before this field existed.", + "type": "string", + "enum": [ + "round-robin", + "least-busy" + ] + }, + "tags": { + "description": "Tags filter eligible placement nodes. A deployment with Tags=[\"gpu\"]\nwill only land on nodes whose ConstellationDevice.Tags contains \"gpu\".\nMultiple tags are AND'd: [\"gpu\",\"nvme\"] requires both. Empty means no\nfilter — any node is eligible.", + "type": "array", + "items": { + "type": "string" + } + } + } + }, "pro.UpdateGroupRequest": { "type": "object", "properties": { diff --git a/api-docs/swagger.yaml b/api-docs/swagger.yaml index eaa9927d..32da35ed 100644 --- a/api-docs/swagger.yaml +++ b/api-docs/swagger.yaml @@ -1049,6 +1049,51 @@ definitions: required: - name type: object + pro.Deployment: + properties: + compose: + $ref: '#/definitions/docker.DockerServiceCreateRequest' + name: + maxLength: 64 + minLength: 3 + type: string + replicas: + minimum: 1 + type: integer + storage: + description: |- + Storage lists RCLONE remote names this deployment depends on. Checked + node-side in executeApply before docker.CreateService runs — a missing + remote produces StatusFail and flows through the existing fail-streak + quarantine path. Not a placement filter: RCLONE config is cluster-synced + via constellation, so every eligible node has the same remote set. + ${storage.NAME} in compose fields resolves to the mount path on apply. + items: + type: string + type: array + strategy: + description: |- + Strategy selects which PlacementStrategy the scheduler uses for this + deployment. Empty is treated as "round-robin" for back-compat with + KV entries written before this field existed. + enum: + - round-robin + - least-busy + type: string + tags: + description: |- + Tags filter eligible placement nodes. A deployment with Tags=["gpu"] + will only land on nodes whose ConstellationDevice.Tags contains "gpu". + Multiple tags are AND'd: ["gpu","nvme"] requires both. Empty means no + filter — any node is eligible. + items: + type: string + type: array + required: + - compose + - name + - replicas + type: object pro.UpdateGroupRequest: properties: name: @@ -2012,7 +2057,7 @@ info: contact: {} description: REST API for Cosmos Cloud server management title: Cosmos Server API - version: 0.22.13 + version: 0.22.14 paths: /_logs: get: @@ -3165,6 +3210,164 @@ paths: summary: Create a new Constellation VPN network tags: - constellation + /api/constellation/deployments: + get: + description: Returns all deployment definitions from the constellation-deployments + KV (Pro feature) + produces: + - application/json + responses: + "200": + description: OK + schema: + $ref: '#/definitions/utils.APIResponse' + "401": + description: Unauthorized + schema: + $ref: '#/definitions/utils.HTTPErrorResult' + "403": + description: Forbidden + schema: + $ref: '#/definitions/utils.HTTPErrorResult' + security: + - BearerAuth: [] + summary: List all cluster deployments + tags: + - deployments + post: + consumes: + - application/json + description: Creates a new deployment definition in the constellation-deployments + KV (Pro feature) + parameters: + - description: Deployment definition + in: body + name: body + required: true + schema: + $ref: '#/definitions/pro.Deployment' + produces: + - application/json + responses: + "200": + description: OK + schema: + $ref: '#/definitions/utils.APIResponse' + "400": + description: Bad Request + schema: + $ref: '#/definitions/utils.HTTPErrorResult' + "401": + description: Unauthorized + schema: + $ref: '#/definitions/utils.HTTPErrorResult' + "409": + description: Conflict + schema: + $ref: '#/definitions/utils.HTTPErrorResult' + security: + - BearerAuth: [] + summary: Create a new cluster deployment + tags: + - deployments + /api/constellation/deployments/{name}: + delete: + description: Removes a deployment from the constellation-deployments KV (Pro + feature) + parameters: + - description: Deployment name + in: path + name: name + required: true + type: string + produces: + - application/json + responses: + "200": + description: OK + schema: + $ref: '#/definitions/utils.APIResponse' + "401": + description: Unauthorized + schema: + $ref: '#/definitions/utils.HTTPErrorResult' + "404": + description: Not Found + schema: + $ref: '#/definitions/utils.HTTPErrorResult' + security: + - BearerAuth: [] + summary: Delete a cluster deployment + tags: + - deployments + get: + description: Returns a single deployment definition (Pro feature) + parameters: + - description: Deployment name + in: path + name: name + required: true + type: string + produces: + - application/json + responses: + "200": + description: OK + schema: + $ref: '#/definitions/utils.APIResponse' + "401": + description: Unauthorized + schema: + $ref: '#/definitions/utils.HTTPErrorResult' + "404": + description: Not Found + schema: + $ref: '#/definitions/utils.HTTPErrorResult' + security: + - BearerAuth: [] + summary: Get a cluster deployment by name + tags: + - deployments + put: + consumes: + - application/json + description: Updates an existing deployment definition (Pro feature) + parameters: + - description: Deployment name + in: path + name: name + required: true + type: string + - description: Updated deployment + in: body + name: body + required: true + schema: + $ref: '#/definitions/pro.Deployment' + produces: + - application/json + responses: + "200": + description: OK + schema: + $ref: '#/definitions/utils.APIResponse' + "400": + description: Bad Request + schema: + $ref: '#/definitions/utils.HTTPErrorResult' + "401": + description: Unauthorized + schema: + $ref: '#/definitions/utils.HTTPErrorResult' + "404": + description: Not Found + schema: + $ref: '#/definitions/utils.HTTPErrorResult' + security: + - BearerAuth: [] + summary: Update a cluster deployment + tags: + - deployments /api/constellation/devices: get: produces: diff --git a/changelog.md b/changelog.md index 5274d910..0a7bea47 100644 --- a/changelog.md +++ b/changelog.md @@ -1,3 +1,6 @@ +## Version 0.22.14 + - added missing deployments function in the SDK + ## Version 0.22.13 - Add licence to new install SDK function diff --git a/go-sdk/client.gen.go b/go-sdk/client.gen.go index afabad95..3c794954 100644 --- a/go-sdk/client.gen.go +++ b/go-sdk/client.gen.go @@ -106,6 +106,24 @@ func (e MountType) Valid() bool { } } +// Defines values for ProDeploymentStrategy. +const ( + LeastBusy ProDeploymentStrategy = "least-busy" + RoundRobin ProDeploymentStrategy = "round-robin" +) + +// Valid indicates whether the value is a known member of the ProDeploymentStrategy enum. +func (e ProDeploymentStrategy) Valid() bool { + switch e { + case LeastBusy: + return true + case RoundRobin: + return true + default: + return false + } +} + // Defines values for UtilsPermission. const ( PERMADMIN UtilsPermission = 2 @@ -780,6 +798,37 @@ type ProCreateGroupRequest struct { Permissions *[]UtilsPermission `json:"permissions,omitempty"` } +// ProDeployment defines model for pro.Deployment. +type ProDeployment struct { + Compose DockerDockerServiceCreateRequest `json:"compose"` + Name string `json:"name"` + Replicas int `json:"replicas"` + + // Storage Storage lists RCLONE remote names this deployment depends on. Checked + // node-side in executeApply before docker.CreateService runs — a missing + // remote produces StatusFail and flows through the existing fail-streak + // quarantine path. Not a placement filter: RCLONE config is cluster-synced + // via constellation, so every eligible node has the same remote set. + // ${storage.NAME} in compose fields resolves to the mount path on apply. + Storage *[]string `json:"storage,omitempty"` + + // Strategy Strategy selects which PlacementStrategy the scheduler uses for this + // deployment. Empty is treated as "round-robin" for back-compat with + // KV entries written before this field existed. + Strategy *ProDeploymentStrategy `json:"strategy,omitempty"` + + // Tags Tags filter eligible placement nodes. A deployment with Tags=["gpu"] + // will only land on nodes whose ConstellationDevice.Tags contains "gpu". + // Multiple tags are AND'd: ["gpu","nvme"] requires both. Empty means no + // filter — any node is eligible. + Tags *[]string `json:"tags,omitempty"` +} + +// ProDeploymentStrategy Strategy selects which PlacementStrategy the scheduler uses for this +// deployment. Empty is treated as "round-robin" for back-compat with +// KV entries written before this field existed. +type ProDeploymentStrategy string + // ProUpdateGroupRequest defines model for pro.UpdateGroupRequest. type ProUpdateGroupRequest struct { Name *string `json:"name,omitempty"` @@ -1564,6 +1613,12 @@ type PostApiConstellationBlockJSONRequestBody = ConstellationDeviceBlockRequestJ // PostApiConstellationCreateJSONRequestBody defines body for PostApiConstellationCreate for application/json ContentType. type PostApiConstellationCreateJSONRequestBody = PostApiConstellationCreateJSONBody +// PostApiConstellationDeploymentsJSONRequestBody defines body for PostApiConstellationDeployments for application/json ContentType. +type PostApiConstellationDeploymentsJSONRequestBody = ProDeployment + +// PutApiConstellationDeploymentsNameJSONRequestBody defines body for PutApiConstellationDeploymentsName for application/json ContentType. +type PutApiConstellationDeploymentsNameJSONRequestBody = ProDeployment + // PostApiConstellationDevicesJSONRequestBody defines body for PostApiConstellationDevices for application/json ContentType. type PostApiConstellationDevicesJSONRequestBody = ConstellationDeviceCreateRequestJSON @@ -1918,6 +1973,25 @@ type ClientInterface interface { PostApiConstellationCreate(ctx context.Context, body PostApiConstellationCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + // GetApiConstellationDeployments request + GetApiConstellationDeployments(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // PostApiConstellationDeploymentsWithBody request with any body + PostApiConstellationDeploymentsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + PostApiConstellationDeployments(ctx context.Context, body PostApiConstellationDeploymentsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // DeleteApiConstellationDeploymentsName request + DeleteApiConstellationDeploymentsName(ctx context.Context, name string, reqEditors ...RequestEditorFn) (*http.Response, error) + + // GetApiConstellationDeploymentsName request + GetApiConstellationDeploymentsName(ctx context.Context, name string, reqEditors ...RequestEditorFn) (*http.Response, error) + + // PutApiConstellationDeploymentsNameWithBody request with any body + PutApiConstellationDeploymentsNameWithBody(ctx context.Context, name string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + PutApiConstellationDeploymentsName(ctx context.Context, name string, body PutApiConstellationDeploymentsNameJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + // GetApiConstellationDevices request GetApiConstellationDevices(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) @@ -2990,6 +3064,90 @@ func (c *Client) PostApiConstellationCreate(ctx context.Context, body PostApiCon return c.Client.Do(req) } +func (c *Client) GetApiConstellationDeployments(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewGetApiConstellationDeploymentsRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) PostApiConstellationDeploymentsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewPostApiConstellationDeploymentsRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) PostApiConstellationDeployments(ctx context.Context, body PostApiConstellationDeploymentsJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewPostApiConstellationDeploymentsRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) DeleteApiConstellationDeploymentsName(ctx context.Context, name string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewDeleteApiConstellationDeploymentsNameRequest(c.Server, name) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) GetApiConstellationDeploymentsName(ctx context.Context, name string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewGetApiConstellationDeploymentsNameRequest(c.Server, name) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) PutApiConstellationDeploymentsNameWithBody(ctx context.Context, name string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewPutApiConstellationDeploymentsNameRequestWithBody(c.Server, name, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) PutApiConstellationDeploymentsName(ctx context.Context, name string, body PutApiConstellationDeploymentsNameJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewPutApiConstellationDeploymentsNameRequest(c.Server, name, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + func (c *Client) GetApiConstellationDevices(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { req, err := NewGetApiConstellationDevicesRequest(c.Server) if err != nil { @@ -6367,6 +6525,188 @@ func NewPostApiConstellationCreateRequestWithBody(server string, contentType str return req, nil } +// NewGetApiConstellationDeploymentsRequest generates requests for GetApiConstellationDeployments +func NewGetApiConstellationDeploymentsRequest(server string) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/constellation/deployments") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest(http.MethodGet, queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewPostApiConstellationDeploymentsRequest calls the generic PostApiConstellationDeployments builder with application/json body +func NewPostApiConstellationDeploymentsRequest(server string, body PostApiConstellationDeploymentsJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewPostApiConstellationDeploymentsRequestWithBody(server, "application/json", bodyReader) +} + +// NewPostApiConstellationDeploymentsRequestWithBody generates requests for PostApiConstellationDeployments with any type of body +func NewPostApiConstellationDeploymentsRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/constellation/deployments") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest(http.MethodPost, queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewDeleteApiConstellationDeploymentsNameRequest generates requests for DeleteApiConstellationDeploymentsName +func NewDeleteApiConstellationDeploymentsNameRequest(server string, name string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithOptions("simple", false, "name", name, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: ""}) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/constellation/deployments/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest(http.MethodDelete, queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewGetApiConstellationDeploymentsNameRequest generates requests for GetApiConstellationDeploymentsName +func NewGetApiConstellationDeploymentsNameRequest(server string, name string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithOptions("simple", false, "name", name, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: ""}) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/constellation/deployments/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest(http.MethodGet, queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewPutApiConstellationDeploymentsNameRequest calls the generic PutApiConstellationDeploymentsName builder with application/json body +func NewPutApiConstellationDeploymentsNameRequest(server string, name string, body PutApiConstellationDeploymentsNameJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewPutApiConstellationDeploymentsNameRequestWithBody(server, name, "application/json", bodyReader) +} + +// NewPutApiConstellationDeploymentsNameRequestWithBody generates requests for PutApiConstellationDeploymentsName with any type of body +func NewPutApiConstellationDeploymentsNameRequestWithBody(server string, name string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithOptions("simple", false, "name", name, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: ""}) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/constellation/deployments/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest(http.MethodPut, queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + // NewGetApiConstellationDevicesRequest generates requests for GetApiConstellationDevices func NewGetApiConstellationDevicesRequest(server string) (*http.Request, error) { var err error @@ -11391,6 +11731,25 @@ type ClientWithResponsesInterface interface { PostApiConstellationCreateWithResponse(ctx context.Context, body PostApiConstellationCreateJSONRequestBody, reqEditors ...RequestEditorFn) (*PostApiConstellationCreateResponse, error) + // GetApiConstellationDeploymentsWithResponse request + GetApiConstellationDeploymentsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetApiConstellationDeploymentsResponse, error) + + // PostApiConstellationDeploymentsWithBodyWithResponse request with any body + PostApiConstellationDeploymentsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostApiConstellationDeploymentsResponse, error) + + PostApiConstellationDeploymentsWithResponse(ctx context.Context, body PostApiConstellationDeploymentsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostApiConstellationDeploymentsResponse, error) + + // DeleteApiConstellationDeploymentsNameWithResponse request + DeleteApiConstellationDeploymentsNameWithResponse(ctx context.Context, name string, reqEditors ...RequestEditorFn) (*DeleteApiConstellationDeploymentsNameResponse, error) + + // GetApiConstellationDeploymentsNameWithResponse request + GetApiConstellationDeploymentsNameWithResponse(ctx context.Context, name string, reqEditors ...RequestEditorFn) (*GetApiConstellationDeploymentsNameResponse, error) + + // PutApiConstellationDeploymentsNameWithBodyWithResponse request with any body + PutApiConstellationDeploymentsNameWithBodyWithResponse(ctx context.Context, name string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutApiConstellationDeploymentsNameResponse, error) + + PutApiConstellationDeploymentsNameWithResponse(ctx context.Context, name string, body PutApiConstellationDeploymentsNameJSONRequestBody, reqEditors ...RequestEditorFn) (*PutApiConstellationDeploymentsNameResponse, error) + // GetApiConstellationDevicesWithResponse request GetApiConstellationDevicesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetApiConstellationDevicesResponse, error) @@ -12979,6 +13338,168 @@ func (r PostApiConstellationCreateResponse) ContentType() string { return "" } +type GetApiConstellationDeploymentsResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *UtilsAPIResponse + JSON401 *UtilsHTTPErrorResult + JSON403 *UtilsHTTPErrorResult +} + +// Status returns HTTPResponse.Status +func (r GetApiConstellationDeploymentsResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r GetApiConstellationDeploymentsResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +// ContentType is a convenience method to retrieve the Content-Type value from the HTTP response headers +func (r GetApiConstellationDeploymentsResponse) ContentType() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Header.Get("Content-Type") + } + return "" +} + +type PostApiConstellationDeploymentsResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *UtilsAPIResponse + JSON400 *UtilsHTTPErrorResult + JSON401 *UtilsHTTPErrorResult + JSON409 *UtilsHTTPErrorResult +} + +// Status returns HTTPResponse.Status +func (r PostApiConstellationDeploymentsResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r PostApiConstellationDeploymentsResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +// ContentType is a convenience method to retrieve the Content-Type value from the HTTP response headers +func (r PostApiConstellationDeploymentsResponse) ContentType() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Header.Get("Content-Type") + } + return "" +} + +type DeleteApiConstellationDeploymentsNameResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *UtilsAPIResponse + JSON401 *UtilsHTTPErrorResult + JSON404 *UtilsHTTPErrorResult +} + +// Status returns HTTPResponse.Status +func (r DeleteApiConstellationDeploymentsNameResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r DeleteApiConstellationDeploymentsNameResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +// ContentType is a convenience method to retrieve the Content-Type value from the HTTP response headers +func (r DeleteApiConstellationDeploymentsNameResponse) ContentType() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Header.Get("Content-Type") + } + return "" +} + +type GetApiConstellationDeploymentsNameResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *UtilsAPIResponse + JSON401 *UtilsHTTPErrorResult + JSON404 *UtilsHTTPErrorResult +} + +// Status returns HTTPResponse.Status +func (r GetApiConstellationDeploymentsNameResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r GetApiConstellationDeploymentsNameResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +// ContentType is a convenience method to retrieve the Content-Type value from the HTTP response headers +func (r GetApiConstellationDeploymentsNameResponse) ContentType() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Header.Get("Content-Type") + } + return "" +} + +type PutApiConstellationDeploymentsNameResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *UtilsAPIResponse + JSON400 *UtilsHTTPErrorResult + JSON401 *UtilsHTTPErrorResult + JSON404 *UtilsHTTPErrorResult +} + +// Status returns HTTPResponse.Status +func (r PutApiConstellationDeploymentsNameResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r PutApiConstellationDeploymentsNameResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +// ContentType is a convenience method to retrieve the Content-Type value from the HTTP response headers +func (r PutApiConstellationDeploymentsNameResponse) ContentType() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Header.Get("Content-Type") + } + return "" +} + type GetApiConstellationDevicesResponse struct { Body []byte HTTPResponse *http.Response @@ -17503,6 +18024,67 @@ func (c *ClientWithResponses) PostApiConstellationCreateWithResponse(ctx context return ParsePostApiConstellationCreateResponse(rsp) } +// GetApiConstellationDeploymentsWithResponse request returning *GetApiConstellationDeploymentsResponse +func (c *ClientWithResponses) GetApiConstellationDeploymentsWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetApiConstellationDeploymentsResponse, error) { + rsp, err := c.GetApiConstellationDeployments(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseGetApiConstellationDeploymentsResponse(rsp) +} + +// PostApiConstellationDeploymentsWithBodyWithResponse request with arbitrary body returning *PostApiConstellationDeploymentsResponse +func (c *ClientWithResponses) PostApiConstellationDeploymentsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PostApiConstellationDeploymentsResponse, error) { + rsp, err := c.PostApiConstellationDeploymentsWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParsePostApiConstellationDeploymentsResponse(rsp) +} + +func (c *ClientWithResponses) PostApiConstellationDeploymentsWithResponse(ctx context.Context, body PostApiConstellationDeploymentsJSONRequestBody, reqEditors ...RequestEditorFn) (*PostApiConstellationDeploymentsResponse, error) { + rsp, err := c.PostApiConstellationDeployments(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParsePostApiConstellationDeploymentsResponse(rsp) +} + +// DeleteApiConstellationDeploymentsNameWithResponse request returning *DeleteApiConstellationDeploymentsNameResponse +func (c *ClientWithResponses) DeleteApiConstellationDeploymentsNameWithResponse(ctx context.Context, name string, reqEditors ...RequestEditorFn) (*DeleteApiConstellationDeploymentsNameResponse, error) { + rsp, err := c.DeleteApiConstellationDeploymentsName(ctx, name, reqEditors...) + if err != nil { + return nil, err + } + return ParseDeleteApiConstellationDeploymentsNameResponse(rsp) +} + +// GetApiConstellationDeploymentsNameWithResponse request returning *GetApiConstellationDeploymentsNameResponse +func (c *ClientWithResponses) GetApiConstellationDeploymentsNameWithResponse(ctx context.Context, name string, reqEditors ...RequestEditorFn) (*GetApiConstellationDeploymentsNameResponse, error) { + rsp, err := c.GetApiConstellationDeploymentsName(ctx, name, reqEditors...) + if err != nil { + return nil, err + } + return ParseGetApiConstellationDeploymentsNameResponse(rsp) +} + +// PutApiConstellationDeploymentsNameWithBodyWithResponse request with arbitrary body returning *PutApiConstellationDeploymentsNameResponse +func (c *ClientWithResponses) PutApiConstellationDeploymentsNameWithBodyWithResponse(ctx context.Context, name string, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*PutApiConstellationDeploymentsNameResponse, error) { + rsp, err := c.PutApiConstellationDeploymentsNameWithBody(ctx, name, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParsePutApiConstellationDeploymentsNameResponse(rsp) +} + +func (c *ClientWithResponses) PutApiConstellationDeploymentsNameWithResponse(ctx context.Context, name string, body PutApiConstellationDeploymentsNameJSONRequestBody, reqEditors ...RequestEditorFn) (*PutApiConstellationDeploymentsNameResponse, error) { + rsp, err := c.PutApiConstellationDeploymentsName(ctx, name, body, reqEditors...) + if err != nil { + return nil, err + } + return ParsePutApiConstellationDeploymentsNameResponse(rsp) +} + // GetApiConstellationDevicesWithResponse request returning *GetApiConstellationDevicesResponse func (c *ClientWithResponses) GetApiConstellationDevicesWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*GetApiConstellationDevicesResponse, error) { rsp, err := c.GetApiConstellationDevices(ctx, reqEditors...) @@ -20547,6 +21129,220 @@ func ParsePostApiConstellationCreateResponse(rsp *http.Response) (*PostApiConste return response, nil } +// ParseGetApiConstellationDeploymentsResponse parses an HTTP response from a GetApiConstellationDeploymentsWithResponse call +func ParseGetApiConstellationDeploymentsResponse(rsp *http.Response) (*GetApiConstellationDeploymentsResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &GetApiConstellationDeploymentsResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest UtilsAPIResponse + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest UtilsHTTPErrorResult + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest UtilsHTTPErrorResult + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + } + + return response, nil +} + +// ParsePostApiConstellationDeploymentsResponse parses an HTTP response from a PostApiConstellationDeploymentsWithResponse call +func ParsePostApiConstellationDeploymentsResponse(rsp *http.Response) (*PostApiConstellationDeploymentsResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &PostApiConstellationDeploymentsResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest UtilsAPIResponse + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest UtilsHTTPErrorResult + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest UtilsHTTPErrorResult + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 409: + var dest UtilsHTTPErrorResult + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON409 = &dest + + } + + return response, nil +} + +// ParseDeleteApiConstellationDeploymentsNameResponse parses an HTTP response from a DeleteApiConstellationDeploymentsNameWithResponse call +func ParseDeleteApiConstellationDeploymentsNameResponse(rsp *http.Response) (*DeleteApiConstellationDeploymentsNameResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &DeleteApiConstellationDeploymentsNameResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest UtilsAPIResponse + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest UtilsHTTPErrorResult + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest UtilsHTTPErrorResult + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + } + + return response, nil +} + +// ParseGetApiConstellationDeploymentsNameResponse parses an HTTP response from a GetApiConstellationDeploymentsNameWithResponse call +func ParseGetApiConstellationDeploymentsNameResponse(rsp *http.Response) (*GetApiConstellationDeploymentsNameResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &GetApiConstellationDeploymentsNameResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest UtilsAPIResponse + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest UtilsHTTPErrorResult + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest UtilsHTTPErrorResult + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + } + + return response, nil +} + +// ParsePutApiConstellationDeploymentsNameResponse parses an HTTP response from a PutApiConstellationDeploymentsNameWithResponse call +func ParsePutApiConstellationDeploymentsNameResponse(rsp *http.Response) (*PutApiConstellationDeploymentsNameResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &PutApiConstellationDeploymentsNameResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest UtilsAPIResponse + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest UtilsHTTPErrorResult + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest UtilsHTTPErrorResult + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest UtilsHTTPErrorResult + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + } + + return response, nil +} + // ParseGetApiConstellationDevicesResponse parses an HTTP response from a GetApiConstellationDevicesWithResponse call func ParseGetApiConstellationDevicesResponse(rsp *http.Response) (*GetApiConstellationDevicesResponse, error) { bodyBytes, err := io.ReadAll(rsp.Body) @@ -25927,299 +26723,311 @@ func ParsePostRcloneVfsStatsResponse(rsp *http.Response) (*PostRcloneVfsStatsRes // const string: with thousands of chunks the chained `+` fold is several // times slower for the Go compiler than parsing a slice literal. var swaggerSpec = []string{ - "7L1rb9u42ij6VwifA0wKOEnbmfVivwXOhzROZrLe3GCnXdh7tcimpcc2JxSpl6SceooC50ecX3h+yQYv", - "kiWLlCUnaZOOPqw1jcU7nxuf69dBxJOUM2BKDt59HQj47wykes9jAuaH9zxe6f9GnClgSv8TpyklEVaE", - "s8M/JWf6NxktIMH6X2qVwuDdgE//hEgNvn37NhzEICNBUt1h8G5wZb6ge6IWaCbRjACNkUwhIrMVYXOk", - "FoAEJFzBYGjWQwTEg3dKZPBtOIgEZwf/5NOxXeg/J1eXnZb3fwuYDd4N/q/D9b4P7Vd56Bvbs4F/8iki", - "MTBFZgSEb5GZIlQeHFEQ6tEWVx7TsyjzAUWczcgc7V1fTW4QZ3T1alBdztvvtZ4PaYwVxAhX1/Whtqzj", - "8dXlsfn8yEsrDdywPt2q3fLeftf1Vdfluc4Jw+n46Gz0JGe3MXjD+eUtO6z17XdfbOMivw3dbNKta0bm", - "OCUHxwKwgqPrsxt+B8zRBN0kFTwFoRyBrMxUkD+pBGFzfQLwJSViNcIrWfpMmII5CP2dpP9aEAWU2MGJ", - "gkR6B3I/YCHwSv/NcALehimIhEhJOJOVEbef5HXR0zehABxfMboqTTrlnAJm9qteQaRu+DFnUgGleONM", - "isbfyiTz33Yjn4ebnGNYuovR5cTebvAaokwqnowuJydMCfdbh51X1uxGWfkOIWbyKI6Jbobpe8qjO31z", - "stvVxUyaru8ptv39RxozeYopneLozjtszOQ1F8rz7VvzaWK5mHIs4jHPFNTP8pgzhQkDcRYFgLpoMc4Y", - "079tIsK6BSJsxtHejAs0ORl/PLq+RkJPK18Nhp49j7ag0x8khlPBk2IP/qP7g0vl7R/c0gWP/eh0GcKz", - "a6wW1wJm5Iv38w0Wc/Av4oOEjQWWlv5BgnfkMvo0XS5QaEG2AtSjO2paRvBgMrkzGXw6ateFnm09IINq", - "4duA+wIXWyxc8C8r0z5necOBHg0HT9dg3GWrK18PFLj39VkcjGBJIjCkbEMer25vqlsEaJwZIl9agr+c", - "A5urxeDdr2+Hg4Sw4s9hfVeMRHdsh54bOy4toTRm291bMaFx+9fZlJJIY3yQZ0dcJlxeVmlQSUp4yDER", - "tiSSTCn4b4CkfoSUJ1+I2lhRuZs8J/OFWvBMQp38a3JPi+9G1PKSeyLPOY7fY4pZBCI00xgoDogdZRio", - "L8Eem8zn3zi3uuTk56bDQWpu8L9gtR1/KtBE0tZwdBIT1QhFXS/kCQ5b4XknSSdAGK1gcLB+uVQ3isVc", - "nsgIpxDXb/VGZIDIDEU8STCLEZEIUy2ZrhDYPmgvAcyMJkGjJsIS4aI5JQxeob1/ERbze+nUDiR6deCF", - "TqwUjhYTFYMQ9aUcma9GXyEVZjEWMQIhuGgei7B2QxGWZmqIEnwHEqVcGhRGmTQilQKBI9O5cS6eqXaT", - "8UylmfIOFiWxT7yz56k4EhlD9wtgejChcg1Occ0aC9oLxjzBhPnxebT+5kFd0AJ7ygnzbPik+PbY6wW2", - "rE93TqRCfIaALYngLAGm0BILgvX9KY4kKETYQ2b9knIJsZb9LcJQejUbvPt3s+zAsDrQXSagBt8+D0OL", - "tmOj1Az+bThYAKZqES3AcvB2c62R/A/TPZdTatP+sR4d2S9TkGjB7/VB2Z8r56Tx3a7InMSixFM3Bs6/", - "+BhigueeLppm6yPQE5ommnQQhe6xRCmW+lSmK/PVykhcoD04mB+giGc0RlNAcpVMOSXRK9+sFE+B2vsq", - "HpDXFcJXf+B5r8gOZMBIcaQWRFbgqEZxExwdxbEAWRfEBxc4Qu5jvvX13X1in9gIUgERVhC/s1NZfS2R", - "KC6+IElYBOjo+gwt3xz89tsB+iABnbDY4NwElMYyeXBRrAMRzf9wfOA7Jwbqnou7EZEaYTy050wi1wbF", - "eSMf4eLsfUaoZ4Cry/cfzs5HKAGFY6wwUgus0D0IQDHMCIMYcVYCgxGP7kDMCIVOaMpTYAF6f5Ua+qO/", - "+VYuF0BpvddE/4y0XGMa7M+4SPStjT9cDtHxxWiITi5vxv/z+urs8qbTSs1KrljkQYqzGVIigyGKKJdg", - "14zwTIEwB/QGWV4DMYoo0ZQuJjLijEGkpJ+pSsXTCZkz7Nuh+d0QScVTw7drgL3ehm5zQxLwcjn3Ae0R", - "hiREnMXyVfPAJXFbqVWQbxY8U2r5IpF6UIyUWg0RYRHNYs1S7DmRmaYfRCLGlT3A2H8mmqvXJ/wgzSlr", - "2CSUGsZlEdTw3j35SuMRiaGKtkOEqeRIZqmm4UZgeDcXPEt9R7jkNEugDVVa0xM/VXIjob2EZ0zJV3ri", - "2ADrJqOrDahRmbD5iHjO4DgTwoKVgEhxsUJ71/8avVozUCuHmAOaAqI4YxoaB8OWKjEfm6qL3lreWlqA", - "bccAFUngYJS5l3Sd7/0vEBxpOdWAD2ELEEQdoLyHRFiA5sWaWkJsGJGFTsQw4w6eD6yeotB3VqcY2w8a", - "/PRJsSyZgtA3pV8fEGWKLAHNMKGZAE1RIQYjz+nPJAZRRhK9gIw5xnvwiZWWn6/di0dGxDp79NO70aTZ", - "jWrQTylIUoVKsopEWKE4E7l8Z1aCUhCEx8XKru2fj7qu8kR18Le3TRTBlPwFaAozLsCZPO11mf7SXkSm", - "AZ/fM3PRymmONqYEqfIr1i10xxSEYQ0lEQqroBx18IkdMaTPb4UkJRHU4NJ0jWGGM6oOPrEbIwEVYPru", - "E/v6Db0rGpcu4RP7+mlweXV58mmgWzhuXWtxfDH6NBgi/e47ODjQLeELRPrvTAvP0iE/XeWt9yd/nJyf", - "6z4O/3UfTR7X5EAtkFxJBckvMl+65ZqdGKNac5dHghDHlfIbI4l5EtxjonJgyPGveJnYK+RogZeAFhmb", - "HwSomd807tf7dlMh6e3FGbVM6gGqNieRr4fzaUdiI24dFBaEioat+NVjAsLpLY7jbupj3SkWPO3Yy8JZ", - "QJXnVngb1val2a1cYAEBm2CUZuUvlnTnH0DdbnwvPxhSYLG8tWrgEEdvAuB2hz+y81wx/cvAB4xO89bZ", - "Lta5w60ELKJFx34VPcMWZYLnc/Gw7zatfVx37aMEvtUP3Y5nMyexH7o2XvQPh4bSI37zUR5+e3sUzpyG", - "LRg7vJ5rMEkJu+t4iAmONE3JH8+19gkkt5QkRPnkL8kzEVmCrgQmTEmfCK6HECC1MBPcvXvv3iYhI6Vr", - "IJ8E7ScgjE7bzuE92jTXRXUw3HGpbgmTCtu3boeegiwJhTnEYVcEHNDkW9tzV0uhx+BWsxdmTHNz76Ra", - "3BZErW552pFimHfkLU+B+beqX7O3c4EjuE0LYdYnh/P0VhaPbt9LWuA55OvbHcXkSkbqoXjqXt+eZ3KI", - "pOXv56b3bav7No/Xgwv9/77rcC/V25iI7ZYgS+p2l3CqTLYu7nBmD9gP50Ec+Lbzgv6oMo7wG7l+QaVX", - "auCV2Ai/+dtnJ8l9c7jOB5ATvrqlymiEcNC0GguyDAAmMN3tlqTL/wgY4vR5VvG1YrTFiRcknP6iFbC3", - "2fTZ9dFFmOgFN+hlv4/Awv3Kfv0rSjKp31AoY+S/M2inAOp4ArUDn2MF93jlp6nZlMGjIOAG/62DISVY", - "dpW1Sbr8rVG00aDZ0KDzLj4aUuzxDAojyQ+GmOHASnD+iULuXW0O5pQLD/p+fFxmFXxF7vQ2A7b8iEVX", - "IAtL+7kJe+m5nXswZm9rcMKIMIUkz600KMIMkTnjAtBrr9bxMcAmgeQ8l+tD0nbQZVBLw+8Jiwmbb73E", - "3Cx7gdMS377mlER+uhKQdRrAztqvHBWp4KTPE+0JHxJNLwhplyefVnHhnbqFEWTnmR3Vq0/bcF+2z5aL", - "aiCbD/TtdKuIzPzuyq7xinIch0SgY+O+1lkICruwYwHMGg5mOECAm/hrl30mZC6wghv+B5cqR+nqJhdK", - "+Z3k9Ae5fQmmf97at5Q5UYtsehvx5Bb/ld1hLG6tR+C+RgsQt1JEt4WnulcUyT1wdwZjF9DjhqnJfOvF", - "jjmFB86ih2iYAccJYRW323DcgWlb+A6fXXfkUHgOTF0Enepwprh14PV/n+LoLkvbbfq9abvetu17ZTyv", - "RsSPIVNQ2M4fwC7jWgvxsRYCanEPLfTYpTNeQ1bHeIn1lozJSqyKuIYzWfHq9jiXid1V1fUwKh+SY4Wn", - "WLb0rB651usBnc0qpw3/wiKPd/BQOtv2KgV2NhoZm1Vjww8SxAVmeA65KtnT1BCpLlczKvfQgluCCe0y", - "wEmpg1HnJpDiOXQZ4o9qH0cpoy4j3Nxcr3sTFon3LdCFkghYgF9QPp8TNj+HJfiVYAkWd6C6bPOi3EOP", - "wNmcj977R+eMKK7/MjGTDyXTNu7SJ7gW85Q9qOqAlaQxu/WvNI2z24Dce3+2Vth6PK4M5B8bR6CuOtar", - "Ul9/PEbCFUysorIllyl3Wd+S48wXp0cBnaphuZaiBp72poXhk03q1Jbhi5vrUwtIOmHbTanDpuhRxv4K", - "FvrEEPNcO7hwbnF1GYNiqW7w/Ib4ntTn64+5eVvzLWTchPWP+vW2IM7z2HrW3WOJ9KBI4fkcfP6AXhDH", - "hB1cFrDoN3RjSvm9piLnPML07PooiqqKjGqg3fECUwpsDteCL0kcEFhjJqO84fqGdn9lNprKjLh4rIeb", - "kQgrCD43DdmJp03fgn3L8RO1jzwhxrFmFRDSpbznwm8Fl5IaPhLAD/DL04qaDYe++QMwzJP4X4TGERZx", - "6bzahmoZcJqAylI/JI0uJ8ePeeldIDOigEvcf9OL1C7gHTLN8uhm50ci9Y78Hv1+qS80eEXWQ86506ct", - "sy/GIy2QF7QxuGLTFhnp3XgOK9Nj+BDshCDANfiJ39xcT3ybaY19JZkjtNlrwZFrhu5ghf7///f/Q5pH", - "rB2NS7FS7hYxiz+xJabExtkvCUaFMVLDy7kbz3l2AYsRn9lL97pVdyASG3EXuQS9JQJvw1lWX6yvy+5U", - "48cQB6NjfU9YbK9TeqwuBpSNGnbTZ6QcqMbZGKJMSKfxrLfQo+J54QSwXfN7XepQis8/5SKCylybjgm+", - "dkhgIkEizGwQEyI2HMBMhSLMGDfK8gTHgETei66QnnafM7ryuzbnq7rc2L9/TeVWLvRpvQjG2b535iGa", - "ZgpJRShFFPCy0qvo8YntZYyClKgyC1mHUpjYMkPi/syYCa/yBoaF4eSYZlKBKIFKqCFnkkgFzCp5gWWJ", - "ltai/GdNXyPsPJljoDDXVMD82/gylsQ3B+nDwZd9Pcz+EguNklKPV5rmNDO+j6VfjvPxS7+NSlNVfnaz", - "FhsYFVq9VnHl+m1QnMmurDN87tYGUo87rqLtdowq47nhvpvXuX2IDRBw7LZ01y2GKHXYyLtRxRrn9yzX", - "ML7GCY2/edSgPw6jsG1txGBYryUXGulQiZVio+wikXVPIGyueZhFNT3J0FhtPrEErzS5wC4wwI0gEEaa", - "GaMUq8VQ/w1LyM058cEn5mZ3MRMuiCEPJEjSmUR7udkO517LS0wz8MZcqXAOBjNYp5u9KfcoYLFVT92y", - "MDR0mvRjpUsDClxXuUdOUUQqyBKbXFrrfwnjfKpxvPiHkBQvjW+u+W878lKac3xdjF761fvjeJJPWvrR", - "99t44tZUbmeXV2z7ZuMaqwQg95dr57zN5cEpoVbSq7tu659zFLCQmKVaHtbc33FgSf6C9yvli8aYkL+M", - "SG7RSTesjDXUfGequ5qou5sFkUVMS8TZEgwSKK6B3mVoYHPn4V5EMVtE+MTiMmbqKTTGHaBTjW1fcJJS", - "GOovlLDsy9BEOHpm+sS0MIrRL3e/DNEvyS8aV3+Z/4Lkiin85QC9n4w0qvNsvjCoek9izZPXGHtP1OIT", - "s/rLIcqMbIGMI+R8ocxe7XrNhq9BRMAUnoMNfakgvy+2JIwINw4tcwzQTGCQ497AIf5gOGApSfXfjsi3", - "BHk9+ns7ov7nx3xU/ceNG1n/+xInEF/bGfTfx/ksxTo/bhIDn32vnRqowpIfy2+CH/M0YHOR2VTT75ZW", - "6NzC7Szi9a3+waU6S/0xvGfXuTLJsI2z6zxc1ftm41LlGZHqQ+kvlcFMfJxzixh22ckFTpsOt5XWc/NU", - "fD5sofkn0OCmacI1633LxO3d18GMiwSrwbtBRpj69a3XjyIV3GVB+13wLO2aS+ipcvO0te/q5Vvb2XNb", - "ft35weqAD07NrYyIvPOromIi/anA8uvspqbbTF2iRy/GKvX83LDkCxDzsJfCVGAWLTqbJRf8ngU0FRlT", - "18HIDJ4qGbxKzAJWto1jKNZcma7xDHSzcGq6XXfDwIBCQFvgJ8DdtlpagBvRt81qUFuZeBCm/uM3fwT1", - "KgV58LvA6cLypZHXopD/umtKBH6/T2EJFLmrKGL6hyi1qkITPHsHq0MjbKAUE1GSsQizeyGcmZwGZqn7", - "uUA1NMYLF1SVC1Nupn3b9hMjTAs3tqlc5Kkgiujn0gyYojQTKZcuI5FZxthdxzujfvCFR196FWzlbBX5", - "5u2SDsKDNjE3e2NnCZ7DGdMn4AHlM186hlHOVF1Oz33nNGpiPc9GepGYWYNP6eCLBLomhY+3b0zmIBWK", - "MI0yarSgM8ETPdUnZob7RTptqYNNtGcNTDYO3z1d7SjSZs5YgZD2bqarT6wwRL0yC7vkCvJYWQ0MdvqY", - "zGa6Vz43+t9jSPnIjvq/0RQovx9ay9YntuA0luUprZ0rwYzMzE9meAEzEEZ7W6zAq7P9SITKMNVvh/q5", - "lz4W4aRcYVp5XNjp13kJMKX5KZjMBJ+Y4WH6QPhsS8IPnhClL8Ep7E2qD6t5u4NUGWCf4ujuHosY6VGx", - "IlNCiVrZfCB2obXEHyWagUW0IAoilQmfRrn0tRDjsIjv9Xvh+PoDKndfhzzbExAZ0zjnPWWcqQX35Xcy", - "vxfx8yV8sz2cQyou0kjpR88CbBQyUXlqIQerRtlRaasWwryeLo7OLm+Ozi5PxmhvnVSlSHGwzj7iXb2e", - "DHxZj47tB4NezAVsY4oSjV1zd0ARZiZvDajayrkmbYkWkfNA5DCctnPsqGX+KgfLNmYQtTdgSclGOH1+", - "BQanFc/tSuv1OpheP4hNcqGKBdr2iYdleHfqK6Ng6o4X/2iHF4GzdG6ka1Njx5xLwWxLx9WxN0HD7siN", - "U0qMVSKw9gI01ajdgLHjOwAqMMEoRyrwY177ApaEZxItQRjxWo9r4RxNM0JjEO5C1wdtU7cIsA2QUY4P", - "PzGTA67IsUIYsj7lyCgv2CrhAp7u+gqbpy9Dmv3QyRWiAEQrMthVfWLj02P066+//qfJ/bHvkn+gPSOW", - "jU+P9adLzPiroFhj9MF4iQk1fJXMUCpAGuJQynPkTjM/D64WIO6J9KO81et8tPfnS9ZW+pyfgbvt0mXX", - "0Nde7uNir2/587Vg2iG5g1emraNZqQWyAkH5PvCUZ8ojthVnYMG8ima/SAM8udSjuYFV/h3YYIW1x067", - "rWx4+ni0nXlurA1BwlqreYSpRcEgzNk2JkGZhn5IOLMyssbTFAu1MbKSQGcHVlPhsaVPciC6KrSfE6v9", - "LI0hDfwUWf4C/J7LINheyTDItp/8E7Ozoz0w3B5TujJ0xKWdfHXgN4wLLx+/Nr/XmWDqfn8sPLEeBzm1", - "0CKBeb4kRie7zpBmNnnoBrO3TFcH6KYY1IxhRySzjTWkGaW5GJ+/CZCAOZFK+BFVrGVtn9W4+GhfEdQl", - "owq/Juw7wK56TRKdjLYpp1dutxDa7foP0EVGFUlpuVeE2SdmGuaQL7XYWH77gFwvRUuumczMWuo0unp0", - "QDQ9dif4idkjLM7OSJee45YLZzYotXRvJGlYtH0E5TvQv86BaSDXD2fDW2X9HXbQKYmOvsIblzm2fn/6", - "S/Xy7PqNxv1Qma9lqmO/GtpjLsmdt3tNaTpUHHZxQbaPGUtLvIELsuTJjGGWYpHjEytgmXE7huf5Zuw3", - "9mAjLKECOZ/Yp0HGrIfjp8FmS2KlcOu8MIUymE1X5vjPRh3Pm3N1OunK1sa2V50T2A+5WBjiZTlnsq3L", - "qfAMIzNvTnQ2sjnLpPdB+7CXLCo/ZNdazCYdlUnK6iO5H+2HfDG1x6XriPacGEVX6Gh8Yczurw66aFvG", - "xVVtOtrqjXWMeHd2rxaTZ1K/ErYnLg871O2ael1DJ4VAVH5Fq9+Uh92sf2vC7PDqG9bgn+uMLcmWs9Lw", - "duO/gkfLVL/9UM75nLDmBGA731zZkFDq+ebt/6h0/R+td7HFwmA2dO1ajEFCy+v+IUUE7OzDFlc0NowY", - "xI+9pf/0ylp2Zc6TstT7H2+qE7/Z5Y6rEwTPZ5LFvPFsHgsOtwPfBwni7enR8QKKAhf15ahAGMjGbLbZ", - "tqnKYN4MFQ+hFHmk5xhkypn0JWWwr0mbnEXZPALOd0Q/k/6rHZPzhpQG/GfjI7Xd4BOqrwUy0Pvxq2vx", - "exZwP38GlWiGFsz+wNJvGzRfJ9nMX7Oo4Qrj2KgITwlVIGToJoOHpkKM0Rjlui0lr6q4Ee4TqR0O3gx2", - "FKnAyVdSLLUc7bjoU2T5CUTgmWgqQeZzEBB3jI/fzJVUjk1bgiCBkB21EFyp4IqUwNEdYfML0AD3gND6", - "+unWyWaDa2YHSdZ38LW58nz9obOMguG3m/DZLCrWw7zrDhHm6wOjPyeEzSlsxpPXY59tAGjbUAdfPc7N", - "/FIt0p76vwr9edqQCisAkg/MZRGOVq9t7pQIuMfUFvWD2BfFupVrXB7dTMZgylmGUruWl9JcEur7VTTE", - "j1HRcNquomHcGJUcMznbUvIwWKQp5pdcTVYsuuRxKF1CI6yRVGAWyFfElyAEieESphnFeSWm5gwlakHk", - "qFK4q94kY8y5aj5qPspv7XChgIsaNtwFoql24eRlTL0Lif6+/AuBBHfrTGJ1GJg2fGyMtm2MS0uzNIWG", - "NCFahA+OvFxbG1pztNFG2ofNYoomHEef1nXIDUzekfRaZAyMR08AHYpGpdxy7VnFSTWzhCf++sxUGhBw", - "cz7ZAR9ngifBi/QLTFyR2cooQUJec023HKIsmQzvoOHqwydXym7x9OHGUQSpOqI0vwwP1ylnvOkQnWza", - "Tkz+7RM2JyycRGfhIkFCQZqmSUORPRMNFwr+jHDaPLrjOaUwEvOkD2cDiErxxnmXf2GiAsUZqx3apQ8Y", - "g+R06bS8Pn/eCExscilmdQxMSyj+Vedmmwv9kGTzo0wtNqJlS4235h3IUaGkX/mPLRogFzIdtQiZNg13", - "miJnw3lEry0KF/D51VyySx6N61KHvOijXFyMLiehRCF0dnM+CQYlu+8hqFx/1hgpXThmt/TQdoiPmJL4", - "A1OhdAuSQlNUddQQVR2UA8ynnReuqFw2L1qJTCqI9Z10TmuVSTjl4h6LGOJTLoKEu31ceCWb27q0XIEq", - "ZZj+3Ej2T4TgYgwyo96czqEUH9ZrL5BNI9fQtec/tZxO9VfqXPAs8NaDLylmcYht35N4DurBhULtSjUX", - "MrGAnlw+HSI5BFc84jScEn53wVu6+nYPTJz+SJlmPYmpasdk5+r66LBj2vjcLjdY6df+yjJBO225kj+q", - "np08DmRJjzfTtFWy9os2CSZJ3IDyJdXuOibxzfDt8M3r4Zs3w7evh2/fDH99Pfz1zfC318M3r/X/3nyu", - "WauLWETn7mvrSp+ML26PRhdnl4N3A+eQxFP5DrkkskMkF5mK+T0boswEQg2R0uthmA6Gpe6345OjkXEp", - "h3tE+VzmX4+vLk/Pfv8wPro5uzKTgDpMsYoWzi10iDRz9DWuDBnl+adsu/HJ6OTy5uzofFJtJcAEBWAq", - "0R6wJVpiIYcoF9nlENkbka/ykc6vfjd7P2Irvew5xPs2GkMM0cXpESpuqdz+9l8nR/8V6MS46WdT3LtO", - "45PJ1Yfx8cnElMtkxvsk13XpNVmSNMxrTQ+RU/ENkUluuDnK5sG0HWiIEqOVLe7mw+RkPCkcTXU3Cvq/", - "EBNb9U8O0VtzCBJUpVNlCaagMCVSHcagMKEmtN0BW8n2YoJfy/DRHd4C0w1b7+AhR7bTzVWBNwT83YG3", - "Bbxuhc7P/oj8DZwuY7kHBiqg5IfUGhaEsd1LNEJIX0HhOn5+XlPQqhhfpetPVM4lzGZqfeuJeAsZ4MYw", - "7o6y6/n74LPp/P1Ekehu1ZCu1rz1i4e+fj/ebEoPldy5FbNeV+OZ1yjoy7EbJ6Qpg2+mFidNeiCjWT66", - "PjuaBkvbmybHPEk4e89VKJkaF5ILUlUOtbc056lgAccg/tCPi62pYM9hjqOVvgfbSza2DmzfVAAr9X9A", - "ukESw6ngyQjLxZRjEYe1A35rehQ4mgR/eY9ZfE8qysiSiiRcuCpoZ1+CuBdEGXWV3X1Ab6sW1wL8Fu2O", - "xnN5R9IP4/Nj87e/RYKFmiwI2LrSLUx16w4up78eJeV81qyG06tOr317K9trG2yoztJ7DeKCsExBoLDO", - "ukxOh7KWud2iwaQB8R8hKMok/PH2OPgo3+hX/bjtRO6LROBsqp+vHfOB+8tVumMOC/mtHqfrgo8daGzT", - "87cD1yrlW3+O6Q+CVu26VSFTfKJ4WkSyyXBe8ZC92X075UHk2c1IJCDlkigeSBosQGkBkbOG2h5BLYAf", - "MEszhoGzToHqrpNN3DfBX36nfIrphCQZVZgBzwLG7RTEBwni/UrBZvGUeivn5ba9Yet5b0gC77O4eqvr", - "sjep2f3EsANWtWlUkp7kxQVN1hDZzfljwnA6PjobBQ2YWna/Yqch+hV3zYdQW8cu3hQm+Mj5DHVQPkci", - "mx43IJpcsSj8veEQtxBSd8ZdqdLG3XSgTDfVjNwb7qiCJFisjjkNOBjZgM2GJuGJP0hvoeNGh8mwqp9i", - "qTZto9Wvubf18QKzeXAGSthd92TSG97FTd9PvqSNTYIr6xpc4Hp89qWazIt2TjQQ2YN/D1iAOMqslKvP", - "cbCwkmmOWi5pAPnLSkprEEuJ3ve3b6aYwYw7ZwaFje6xltdkfDK5MdHIMy6QLa6DjinPYmRTz6NkXTZC", - "C3HKuOW6hhPb5Oj6bFByPhi8Pnj79uDNr3mefpySwbvBrwevD1673C9mi4e3Rr/z7uvAkdHNiC2VCeaS", - "2Nl5KJ+beFSEJcIopZgwpOCLQrY0kFujS1rH2Vk8eDf4HTQgSsPCrAuymfLt69f5weQeefBFHZoxDeYb", - "fK5koJkShsXK445cO9Or/9Jb/+31m5ZTtKtRUTbneCb9wLADCIjt9L9+z+lPuZiSOAZD/P/R+nQfZe4z", - "V8Ayh0fTvIJZJjKtjFP//vzt83Ags0QTVBNFfs8ox3EJ1EzeNxNM+O+BjYAefNZjHuKUHN4mkDjxqxF6", - "bTOUmUQYTg/pkvW4NZv4QhtzPc1M/hcfDB+l5MLOuBWQcWq8AnXvwz8l73zgZW/9DsD90GkfBcS/wyIq", - "gP7b6398/xVcgFrwGF1yhY4o5ff6MLrA+u+g1uDnANRZdhsgHhe1ZBzA+2DUFZyxPBCkes/jYCbidRMC", - "tWIzD4LxDtkKw/D9+vtf7Hscozwi55mA939+/xVo6ZeSDdFoK1Cfm5BukWflWdcmQjiHyRy0L5yp5rMr", - "DV8H5msue2juofmFQXOVUh9+1e+Eb1Y0oWDVslUwH5nfC0C/zKMoBU7AWmn+XctUplsi96IxzxKTy7F4", - "lBTqovwJZOF0faibwvPnh2HX2x69ng96/fb9V6CFoFPjPdZVBFo7DnDh/AEQrmEamq5QoZuvs4+tolCP", - "Uz1O9TjVCafSzCeRZT1O9TjV49ROOFUIhinZV0Xl7rVUuKm6SvjSlucqquWVhg+JkClxRcFriPIoJ20d", - "4XBKDtyULtVDAVr1MzffbTZdxd3R1XD+23PRpz0H1Ox1ei+MPowcPdgobOkoQAnfS8KqX1GNKS0S8EK8", - "Hk6ivXuiFnnyNRypzCTb1Ki1wHIBxs3UKwBXKEKvsn4W4N1ZCaHhYg0MYeDKFWkb+WldqKBEGDG4LzEU", - "DVTWtldkKS95ARlziChZAAW+dx335ILfM5vEkrMI6uCXa+++G0eyXuWtOVJexwut/dJ7ntTzpGesuvRZ", - "dL/DAh7Brnvsij9XqU+IjNUF5ZIW1b1LN0DFyOa2lu0XIk3C5mKaXyQqtR6WCdwQnV2jwoXUyPaVfC0o", - "9ya2vh3ex3BO39q8h9ey8JO9hx+ZqNqTbUFUTwnQWGoR3z6UenLak9OfSMS3eNBKxM/JVynzl18ss1RR", - "C2W2aakSPCKMKIIp+csVNVp7/prE1AAxxAfIlX2SKBWQkCwpis7bvPtsf122I+GxKezgFdLeu6U+DTUJ", - "5zDzYUrpJPL4g8cmJb0S78k8zF6gPDL1g1yO2zlu1BB7f10FqflNjxKcmqJolHonK5Uac35vebzpHaxs", - "WnjXTcsHB4GHvlvncR69+jyY7Qt8Z3uvqANAlITVLXAhDUn0ThgAiVaX30YSfb8GqMcURXuQe3GWjS1w", - "WLdohOG/GhDVYJV3Q4zX7Z8DR3+5tKo4eAKy0OkRgSiP7upOpW0u0BGxQ8lwKhd8q8tp7UY1EZoUndtT", - "I7SXl8USNmFaSfR99UxI1U8AbT+eTL1c6bHAvgI5TB3CGjKu0F4JRzX2vdoVCxXeEQNNxx77euz7abBP", - "iywlFNOoQaQikUR7kvwFQxubFvGMqSECFR20QrpDiG1UcqMruut+otv+eF2J1UnFoQdsrzN5hjqTLpCu", - "waxi0thVU9HFCd0N8jLfkD1r+FuzBuszt6lPz1+yeXVLWXqVtEWdQwGmSm9bDqHRZ+y6/Bgs2o01bUUS", - "tynkJrCPzfxEz+IhsrlzbGnNotC4reIIyEad96yp98n96SiPRQtTp9uVO86pUI4dXchNR7XLrsqWnm33", - "yPNM9ClrXcqMC4Rzh8TIYVEX5MkY5bacUFtW/cH26BGnR5yXhDgWbP2aR2FlYakwNZXU79opH3Mc+prj", - "47fDGad5JtJunOjUdfzuaDWsVRp3K0JnI/8UJR79gGlGJre8Pn49upGNXSn70vhm9v/OwBi93PRuMT2h", - "6AnF03FYh8cVW8UusmmFNIjCxaG9XmlNH0zvZ0UekOJolq/rsQhFj7099j4Aey2eoD2LY6/KwnEOjhtP", - "TlF2rNgFsWU2teRi3ym+9iX5C7qLAJN8HPdAnuhR/jbyQLH7Xh7oKcrzs6FalZVGbGNFLV7eBdQ6gMXt", - "xIQIs30JLN4vEtI2uj/eL0AtQJR9HBdYItMZ6XEIm6MIp3hKKNHwWQqMDXhBHmM2ARabMqXPxgP2GaUm", - "XPs/LyC6Q2S2cdpEojybdEMKwpZuz/peZxmlVQfW3BizJ4FJosgS0MxGDiVY3kFsYNBELhT1dWxloFB8", - "8+P4O2NKr2YGbTre+7BWqtcl9G4aZ07UIpveRjy5xX9ldxiL28ik8t23Z3UrRXRbVG+21v8aXf783EOs", - "X2hOTh+4ltDBQf9nW4kkWtQR4BrEjItEIlOrCBVAK9EejuOhFs4ojkrlrxK+hNssdf+I+T17hThDppwp", - "cgWPaoE7eu4q+D99GKApg9QQA2i+u/i/9b77SMA+EvAncpk3mOdwuw2RyLw80pAAyyQ1lxMQYJOOK5a4", - "oWOXWABKBZhesX3+FX5CdoxXgYjlJyUZu7C2OmxkpTQo9iAc13u2pKRH4+fE81+wSccyz7ZCSFUmP4xt", - "TrGQYKJ/BolGl5N9AdT4jubFjJ2LjqYeKRdqiGaY0imO7obIlNqjRCppvXqiTCpNbZgSZKtkMvoeqcgu", - "J3ayBtFkdDnZDLDrExb0YsrfoM6Aoyg1BNhCTtZJUA6nrdwpKuUW3zt/iidC/PVEByNTy9fM5wD2n5Or", - "Sy8JMC0tOTvMmPkvSvGKchw/X+TvQ/x3Y6QGIhAXKL9pjCoQ6opAV7GgVC80hAw17VdAKbXu0kfk/xQA", - "9TvY3ItRJgQwhS5hmlHcRFPbQRODSHUjrseuU1vy+mV/hRPqdfQOV89y2/ufRxfnTxxZ1EP2j86GYuEJ", - "qQWRiPHYJOotxx1VCefH60vEQN1zcdcd3k3ilY7gbvs8YVBDdX9FYkgnG6A9yyoucQJDROQ5mS/UgmcS", - "hmjhajoPEUnHmM1NHsz+GdEnLHrKhEWPh44WsGUXaWbkuvRE/2VDlHEJ9EnE1g2gLOlkEgTa48LkPCAz", - "hOOEsFcNwDbsQN3L8PR93ooWl9o9Fjd5QS/8/I0oq8UHo/OcuwzaJoA0AqHITG8N5K4k9/Arib8dplr4", - "7k58z+Jr3XGLH50DYS2eHIb83Ej8MnN89bJM7/62O85fm4ItfmxXHJma/UgAjhbW+WzVHctZN6GK9QLV", - "A7KgOYtU9T5Hl5OSjepRRBX2tBlyq5NdTk6YEquQMUtvbWWgtfw87p+dfc3Th9U8bZCHCrDbhRwefr2D", - "VbsUNJtI91+w2irrFBhxZxp7RB37oc9n+reoxBSCXDTNISTMEDow7R4ye8jcJdPuA6CzoS7nM4LOHy4i", - "5bnxyjyrF5D6t+yjlgIJGMh2l5MgJmrfOSZ0spGdxESNcoeG76VI1ZO2U6PqffUq1J9VhWryVJYNBl7F", - "SilMqitazEHtM/ii9knaRavyO6hL+KLO0l638pP43mggQHiJCcVTCujsGuE4FiBNUgvdoAp5x2ejMRKY", - "zbu7eVE+76TBO9ftezB7+WDm/J4+Xl8aJ3xNuai9224A1NW04yw6PQB1VFflkcwa+y+PbiYookTzIOdZ", - "p8kAkQhTsuxOBNJsSkm0v4OXxLXp+dx8JZ6BE/+Ldpew8IAIm3GRuKTCU55ZIwTjbN94GkPs96voDH4C", - "pAW3tlA3Nh16ItKViJhzsxRkTf0f5tgrQCosut6e6dLf3w73p09u8wZz/o1ZjPTkLqqu812qjDGgnej/", - "jevS3+XORl0cmewgVVKqinPdeoXC7qrpxkThzV5Sl/g2v25CoFBFjq8ubWjH20Gfwbw3tHY1tBpA58LZ", - "75EGJ/Qnn4brThpw3e6x0AN1D9QvDqjLVLtLtRrdvU2pmmIhT1pmozuW9UjWW6B2siUPXdaCoca2uPB6", - "8OKbp4ZrwUu2iEc9bvW41ePWjrjV5KrR41aPWz1u7YpbubgYY7mYcizirdlIi5Yuc1tZh2tqmOkDxISB", - "cPWyTRTc5GT88ej6OpSE0fLJUbGIZ5eElChIZIdESvlOTCLHwTrnKBYCr15kEtI+ZdCOaVDXCGOAqSFZ", - "UEzk3Tbl6Mi06ZOW/wRFz2N3lTk8TBQXeA6bAHFo6WvZja12KglWNgWmq2cAsRndEmT9+5wsgdmieiYL", - "NbKDHhgWTARIlGIp77mILedwFP0ATZQAnEiUCj43/iE8U2mmDurZ6qzWzMCnXdETOdBJe0wHdhI9X8hn", - "zrawJ+FWsoPPnIIv6jClmLCOiV/s0UGM9Aju3JBLEG4u5t9X1yfjo5uzq0s0+XB8fHIyOhl99gtkoUV8", - "nxx1Tzr7dlbzpNNvoSlPOvfjlDTRMI4tlHOBUiwU2bC0eihLJawykHYbGwdcyvldlha5DCwl+TA+N9ZA", - "UcpRL0ByuoQYnV0vf8v9yUKiHttazUxPoXg+aqC+Rybo9y0g9OiSZa32SRfJsM8SG0CfskVbg4+BZFuV", - "48P4vKkoQ8zkvolbDuLHRxCaxWqgx8oMTCSKuBAQKboqFdeo40wYG4z7VUuUsGHVbkfPBDF+rvzPPV49", - "NBlIAaIbuYJboSCP7kDsO6+TrfEbI9N84lo/jdBpl3RQmaqS/sYrADq3mUfIffNwIbRYhBVEn4OY2ct5", - "O0STWxAsXLL2zLok7FNyB6/su8IlMZNDtOQ0SyBPN54r5sqPTgvYJeSDpd7jFi3EiW20hV1NjC+ZifEi", - "DI1Pj3/99df/dC9PtPf29ev/2H/9Zv/125s3/3j3+rd3r//xv14FuNlM8GTQqWLcCYsfZWbFu817QRhJ", - "sgRRPkcUlkDRXgzTbD40itIhklkUgZRDdI8FI0z/nqRcKMzUEIGGi9BKKJ+f6wEr64lhhjXQvRvo4QfD", - "7Qs8zSjdNy9SCVhEC6RAJIEpbYtuB/B+cnWJzDgIS6Sf5sg19s+R/9lhims8J8ylmMyE5ALtXRlh+WyE", - "FvDFzfcqWBLQRLH0JQF/Xu2apWGWGM4IVSBMniIWo7QAnRINvAAlSFSuwDfDSxJV3B43jgpsAQhDVrH5", - "p6nSZrvV5f6heyib2nBKIwZmiCQWEn0E9tQtYPuDYB9YxGOIkSQKkHshzPT6yssJId8Dy3LmfsFpihIe", - "A5pRPA/SErHEafqImMcjBWpfGgGnCoy5xnQwJQzb6OFtclKb50d4wh/wDHnixezyHHniJT1SXFoZSbc+", - "RWZcROAqLu278iZBRfyNIPM5CIkwSjDLMHUvdTNTEWvpKtLYwWRIj36qJ7Yb/bCuqtI/0Htr5O7WSANT", - "JZisQWIQDeag9m2N61bVSl3xbFevzL1QrCw4IzTE834HZWvhPhTUn4j898Dd67+6MBqHBQ7ig1b/ueBZ", - "KrfiVSk9o+AUkO2G9swfZyP0KXv9+lf4f9Cvofq+v9t5ejbybDBtJ6+BeX6NOUC5H8rxLBuuj0Z1JF0m", - "whoMOZ0RTmx8XwoiIVLaMrvXQr8lsMoEvApJKiW4eny9ayr4gV2/maZB2Wq+r7WcMShMqOyTVfW16H7S", - "lKIGeX10oMpYTH70agjQZmYp/bsmDzXScIBONRIhMrOl402tXKkIpQhLSeYMYqQ4IupgC6kowowssTiL", - "tyk2LDY/LNk6YQrmIPps6z3SP8OU7y+I7BS5YIMkJ1Cd22ouZCXDn+nzi7QCBxdd5I1M/VgK8jTijT2k", - "beLNaV9kt6dxPY17MhqX5yLdLlYZs00ptLr51Y5SAUvCM0lXKEspxzHE1vJTCsrxPdfPdJs2kW2modEy", - "WJq6ty5ADl8UME1aXz1mxNuPNdD8QANEJzLTG4t+BmMRZhtY26QlNw22uc6c2UZbkPrSSEc2GZ/z+LFE", - "Qz+3mExt1VqfnZWU6MbzcP/Uc8kDs+8zt/Te8eHRodUd7dpDbJPJBD2+LNgephmlrWD3Wjd8APymtv/3", - "BN6Hu0/qRVdcJ3vnxQ5lwvThbQDmTPAEYSRgTmQ1w3sTgO6T2b55Lm7NCbuG1bPZhevRA20PtA8CWs7o", - "CpEZIgqZCt8KYSoAxyst5ktgClEeYUqbwZktSZMbye+uRGZusXEoYu0ad7AyZhqeWhdDukISWGwdyszA", - "NgjMBXOazKcIEkxoyH5zZpfzRMVGJIgDO8OWAgeXJLorjFD6fYAMnD9bNUevYngmKobeV+GBhG6sKVec", - "Uw9KWLn8ubH7lIjXn3y67YXzT92k96HeybqvJ4wzCjH6055iIF+L/nq4tug1xkfp+7Aq/F3SWUaCs4N/", - "8mmFfPe3+3LRvbDm/MmnVgo39T7GV+FM3T7gcwRgK+T9DqoHu75Y9TPR5zm3ICNkUj6X+rmH86wpkUaJ", - "LWAvMtYK7McZ68G+p7aDCxMIQFdI2eAAR3cVRyJj22GNbVd0OGhjj1D25u8odblSa3SF3HG3kbyk4mkr", - "MjDRDXs60NMBDQgIl2EsDGKUSLUfE7EF8TX4jojYHoVtkv8447ALGH5nFVWhGFmXY6tbWO6ICIgUFyuU", - "YrUoTXUYDsVViz4Ut5f4njQY2NTTtCt34l6cA2pjiiyDhYkLDd6OiXkQcQ+xP0FqxnW0pgUAdAcr+2hQ", - "CyACUTytFs+ph5BTPicsrOTXCwCm9JkYRX8mQbhIjLIiPFfkD5EEJdE//3WDIs7vCCDO8lwSIcX+uVnB", - "E+r1zQRb1PqmDYoExHq3+DlHZPSZp15ERrcPGlOog+0c//QxVpGPZyronXduXv5ZtdaywcDpCkUUsM0X", - "sUZRk2rE4F0ooeG5nfG5wPIzik6uXZw9p8DNJVjcgWoXDmnbphRHgCTPRARlGl3ashyilGYuQ+6C30dY", - "OgeEPESZ8iw+CFzthVtSz9lfft1rk6mkBDbURiVUWLn5XAZJaBX0ngpunHDLCfGdM8lax1CiKRAbkhMC", - "Onh+SfC3j6NR/EVmt+/Z7iMgWIWT5vnIAmQexHy75fLCtHraNOJmjobAG/P9AenD++otPWNqsg8Y8Eoy", - "qkhKoZShX6JMainUNBCnk0ZdRTs1xVpF0VwqiScJ3pegG2kuRU0pwlnlKWwScytBIJiZOykm69V7j2Sv", - "MAEJ87mAubkXd8KbZUXqqohkhpsCwMeQ8KXLYPf29Mi4GNrkWOtqEoak7+E4IQwVoNUQ530xw0+pedBy", - "xtvTI1NuvIF2Fz6FTg4zu7A55UGZvdrUeL1C4vm6GL5kr7oCxpyCry4PDf3vik0X4Jurm+sCL2tKi81C", - "DKngSyIJN5amcNb5HEd7UH/hkreFFQMojn77AM2vh/6IKXFB+hbKFL8D5oczxZHeq3EfMxLL/gxHSkN3", - "RVMW0kd/H55gMs838IT1JnvC/xNigynOsTJ4kF9y6AlK5hpt9hcOL5pforbxH1yqp60w4FZ1w/VUFzz2", - "wok+SkP19T8mKOVC1Xw3++wQ/Vv1sd+qFjbRsVGalwp9Ko40FuWFB0wu6KYIqIRnrAXOmVZPrP3RczRp", - "f/T3XvvTY9QTYZQBL1xS+zSreXTzrVoe26hXrfwEfijmwiEuqwUbAcQR4MOv7h9no43UfwF1zaVtfpn3", - "2hop7Qh9KL0WKw30AmuQ9XD7wNAiFzSdywPTlYWUoECQVyzaQtou82Y9oPwkBK4KKN7CVMNmKbECE0/2", - "LDN5hcHNde3KuPk0zg7iH6HkW/8g69GoSz7gKio1U9v7PLxgC2rdd4wveMxwgmtsNI9xJapg10CCehk0", - "TmN9Wjgx6V0sfoeqz5m237fOcB+48HcOXKggdgF+TXL//RmTCtsMXn5N/x+YxRSk09xLBWleAIbYrpZh", - "rbNHxljhKZaAJKgsHTplY0XPaAtLWrOwMRHkfC9kA7hcL/Rp+HWCCTtYzxJySz8rb9mchbOiP1Mu3ZeE", - "ef6O6deCRyClwVmyCV+N5ZUYV2SW+ypvewNV2m7hze0qZRprn+OH5dF3rsbac78X7slZAYPCGOx1Xs6B", - "ugqXAdg+FIDjLgA+Bhzv6q9Wnhl5wF6G8vnF8uXJev0zrpc3H5KlQtxtID2WSFjk24bhPAVG4nYFzJzw", - "CDG6SoGdjdAxZwwihSJK9GuvIl2GYq2u7ITPLj6CGP18q2u1uz82mx6s4yWwEHj1IgMoXmCuNQeBFvLK", - "8pkD6LYV1VpAcug5VILkJ/CK8kCaB4rKp/DEXiQ/IiRpY/+dMKsvZdLXaNu1Rhur0hcfeaky0K2F2nI/", - "/fXQTSSnMLoFTL6W9Gyvo1SlDw+rp/T8LL09dj0DuXkXE3ML9BpuK80jCZtT2Il/lwXRF4pDL40Z96j6", - "wlDV1c+pAv+mK0hZ1s682GoC9as1BHeSuLPngbE/Ss63Bc5i1Mv7vbzfk7lHJHN55cAOAn+e1WvfBKKG", - "TbYTW9nDW84DKb6OaSUz9yORJR1bSOtw7YYzIYpPGZJVmahL/Q+7mVmtkkkfstVnMXmQjdYBYQ2nwmFi", - "aTUD84aKYAHRnamPjtGH8blGPwE4WpjUgeWwXIwYZ/v/+PIF5eAaeFJct6hT9WF8vg8s4jHESBIFZmrF", - "UWr7+mxa/91JUBnWCZFYksilT+IxoBnFoakkiCVO00H//u/R9nuV6jLp+lyoe9DLQkSUM9A8V2Ghtlih", - "x6bx2LXt/Rk6pj7Qp2aMLONjfY5IQMIVIOcIipI8Rins0marnoEIS0fHLhZdWhmoUibN5s7B9dppe6Uy", - "R69CAtI4n/sJZaN8ji1i0bi8gbx6xdpHLz8lF/TfC0c9lX2IcOSAydo1/RlL1vgpoW1+bCP/9wmyf5ak", - "NiYy0SWfMq+1pcmtvjUPVZ3zbqTmsCVSpKnCjyOYZTR3URYFIw7A12Ow6d6q9FO6DO8iuphMwQb0ShBt", - "NSt1gN53LVvAteuRJyQzWRMSHC0IA7Rn6skWmefvF8CKeiGESRIDwuukC6+acWGSL77HiD6V2cOpfoEU", - "ZYhtfGzxTIHs6hSYCv5lhVzfAHznH1+u89+13qXZx7GlKL0D4A9xANyAthyW3Q9t3f9Ko7Rz+itB8FMZ", - "A+sQ5nlZelf88g2Anr33RsDe6e+7OP1tEgQfValyyMOvDCfQzu8vTGrQdJXHXwfc/SzRubRtGq0Lli6U", - "o7k3crvYL72zX29a/17OfttQqq2nXyP+ECX9OFSWO18kAr1ELtzj6kv09qtg2Jon+STr1s5+3ZmedfX7", - "0Qj7I2X73NlP9DJ+L+P3FO5xHf3aCvjOEWabcWySN9tCpS7wF5JkCWJZMgWB+GytC87rsWSCBZxyKEmI", - "8rnkEKZgbop29dkXf7KkemvwaEoGlkPp4dei/Vn87bAl0B6v+2xP05Cniz4bIS4a+G1UGbTPH/q3geAz", - "JlOI1PrBtgnJ2zOJBsAZZ4rvZ4aAH36VCqtMfusO4keZ4pYLTMwQPx7kh5660vlGkd0n2tOD6OlnmEp4", - "5V+AzDfUo9vfBt1OmDE0c4FiIq3Lcgl6bNmiTQzcAfeiBUR3btTuOGdcrC3S9RymB/mHJlbU0ITuF6AW", - "xs+tAIRfJCIJngNaYGfYA4GWICThbO2UsQP0w5eUb/U29sD9ie3Xg3wP8g+k8gaQyrC+oUYzAC9dhEcM", - "M8KIUxR1hXXK57I7pJ/z+XOUpOrvbcrniBIGj/LcrmckJlTZAvlSi7kSsIgWLlVdMNRGt+mW+PiGJCAV", - "TlK9iRmoaGGnzJgiNLQdLNUYIiBLyG+rw4zWDIM4oyskVQzCbjIwF2gIv2J05ZtkyjkFzHqy9DM4ldny", - "wRb6Hk3YTDDDczj8iiO91G9BB7Qj812+Q1LxdIiMg9swd88cojtC6dBErSxhiFKcSRiijLl/CLD5woco", - "ywXTlrTuwizPTv4saZ5eXgJMIZyv0TNf8S08FbAsMY6BiptQwLV/tvuXPmHzgz5icxSZCYp0h2w+FVnZ", - "3TF/Hj5f8aRPwPmC4wdBzLhIEEbJJgIgLSA9BmGqlWaK25Vm8hCRjWpN8TMkJG0LRL3Qt0iP7C+5SJXC", - "0aJepGomeFJ+Je1Qi6jH1V5v8NPgyZHy44ni27CkHSfcQVNQqvXVa8V66H4UY3kOjSaSVS2g9ENJY2bz", - "KjGIFMRI8R2g3qzsIcbHiRng2Roecy5i9xn/bYyPvSj4conABJQGzYxJWBcvJ5K7uj2P9fRbmz67So/P", - "yu75ZMU1i/WfcpEEgnLcBp1tuq+q2VOFJ6MKhZ/nJur/IpEEpVzpoAYqoLI0nLbIKZukETaAKSIAGZMb", - "prbSHiJs7QEVYUrfFaX4XBG+Yank3hDx1OZDQcecSQV51TEnr9gSfUUb2/Ho+gwpfgesKNh3gK4YXW2m", - "H1inQdASEGFoXVnP5IE7CMW4TswZPGGJPzNBKGmS+fjEbu89qfiJSUVBC64Y7MsFVzkWpIIviSScWaNs", - "MP2BTLBQ+7FeZbOcr9uNYNZnReocbDS5OBrfIKyUINNMlT0XrDnx6ObIkL7LjxeAYkGW0JxwTjKcCky2", - "laeb5M1qxM13IOsmBPJj0SOMj85GNnTl7eBbXz+up0IP1mVwV3wXUA5f9WJqdeDfptDugb0H9p8G2Dcp", - "vTf3QsgM6/q0iSfdWNPTRpbuhog9HvZ4+CivZC5QnGdp8OOiJw68M//psa7Huh7rHg3rAozQ5zXZ9ATS", - "WNnOlfEJcXPo9+w0LtrZI/gvrlhkPJFFNh0MBzPyZTAcAHPBIC5u6ikcE3tU/xumGBhnrIzRzgVxTwPh", - "EBkYHKIZ+TJEFgKHeeDeq2Y0t+bVbbk41QJQlAkBrFB3OSPuOt98hcYYf2meiQgQYTNuNc1WFWZ6Bv2i", - "1+bePi1Y/OxyJVe0bBVAaNR4ZjEPGz3GsK93DEzpTYFcl666J2qh/yKlWk+Ko7nATCGgsDSJbPb08K9Q", - "CiIhUnprw+cio17HE9Zt0ONvqdmQl70yaki9cLePZ22G6LHgZ6iEc2IRRmOQAbyExxCu4ZAxU4hlq2fC", - "B9fuadDKFYU5uNBzFKKDD1zMKpBbw+Mnsuolrr/548oBGEYzQsFxuCbBKkspx2U1op/5fTDNTFY7G2Ou", - "h8/rNzoGuyezNOVCSfRnOh+iP1OYD1HK5kM0J7MhmibpEMnlfIjuYZoOkSKz2RDhJZkFixjZWdtoTt5j", - "adPfGYZlOLPpC7FZ6fdIipdkVJEUC3U44yLZzzPBrUerZoozx1g/6LPK6dpN6EcbFwlWg3eDKWHYxJrW", - "HpGlffzbjf7Zi/W9E0Gf0O5FVD15yToujbcFtWx6dGiJvEWRCUSN0WhmHL5NH/vsKLyi8nh932v1g7QZ", - "1Dom57PTPIO8fD+01IU+vL68RU9XnlXIRyarORHt323rfRitBY4iIyoaMuIpM6kFKVtpcn+KJcSIsynH", - "IrZuY355za3qyTQXdhtbdBd6FYVTaF5wstda9LShHW34wTU7XnBisnIFkY3Kmzl9qkg9h1+Zq5jfWDzE", - "OrBo2lWhW9MVyruHa4YYinS5btZclFwPXxrT92Rcf+2rh/Sk5m8qhhRFTQJYvqWYiUHjvBB0rq+RKURk", - "RiAOY3XpMfPSUfpHVBywD5n+4dJTjO9PMWxpFYP4Vb7tecBgFS18GugYF4Xyc+Ihs2iBsESQYEKN7V5w", - "6qmmood8VqTjid5HJzFRW15HpwRoLK1y2UXm9g+jnvb8zAblmKiwrJK/SJacZgkcfrX/vWztVf/RtP9Y", - "9NpGVnSbvHa2nUvjopvGS2WW5bH7/C5/oyxfTsp2QdwOWupesbXwbdtyW3aij65VDyc/V9GcZXGvXZO/", - "lSHiyVJl2Ekqmlzfwdhmaz1uny+jd5v5PqrLChqFyCzlc97KHfmYy4TL3EdGd7PZ6q8vfy+MwzXqfK5H", - "3wrYpvthyubVQ93uKxKA4X+0neG75S7Qz0Z3gNQeideOLiLKGRxaz+5Dl3K50SNwbHrYkKbjPEXzrkRv", - "q2fdGBJeFLG0BjfNwodI97Q+5yWZsXcK7Knb01G38bGGfJMXvlL70f7uRaiyYabpNVRGqlH+oHkypLoy", - "X9bYpB9VdleVB1WPS88Ql3Z5BrGdQDdL0qZnUAVkdds+iU2nu8mS1Eg5s4zS/H42k1a1uCZKpLLXKtve", - "1nmpS39pnd+LFVySaM9QUJM/dpWCKXQzRIzr51cMTBFM5at2VynxsoPsNcFL6K+vW8ZPvASDc7ujWymb", - "Z+a7pKxyRx/KdoKnlI9dZsw1R+8F414w/h5pMhmCL0QqwuYdZQwBJjK5FdOyia97ZvXSzdhzyqe4EHaU", - "wEzOXHix3AIwBWzIQzzlmWrDJ6+KPkemyw55XEzLnlj2xLIG+3o1b35MaomzJKWmShXE3XHQxduiTOr/", - "J2zGXfk9pwDYU1xhOkSZhHiIZgJgm/S6nMk1Kd+Gkx9nck3Le2T8W6ghNNh9PJ1YOu+gzcTaQtwkLZgp", - "NMpZX4BM0MG7wWFkdNqDb5+//Z8AAAD//w==", + "7L3rbhs51ij6KoTOBtoBZDlJ93zYE2D/cHzp9oxvkJwM9h4H+aiqJYntKrKGZMlRNwKchzhPeJ5kg4us", + "UpVESlWyndjp+jHTsYp3rhvX9c9eJNJMcOBa9d792ZPwnxyUfi9iBvjDexEvzH8jwTVwbf5JsyxhEdVM", + "8IPfleDmNxXNIKXmX3qRQe9dT4x/h0j3vn792u/FoCLJMtOh9653hV/IPdMzMlFkwiCJicogYpMF41Oi", + "Z0AkpEJDr4/rYRLi3jstc/ja70VS8ME/xHhoF/qP0dVlq+X9DwmT3rve/3Ow3PeB/aoOfGN7NvAPMSYs", + "Bq7ZhIH0LTLXLFGDwwSkfrTFVcf0LAo/kEjwCZuSveur0Q0RPFm86tWX8/ZbredDFlMNMaH1dX1YW9bR", + "8OryCD8/8tIqA29Yn2nVbHlvv+n66uvyXOeI02x4eHb8JGe3MviG8ytatljr22++2I2L/Np3sym3rgmb", + "0owNjiRQDYfXZzfiDrijCaZJJkUGUjsCWZupJH9KS8an5gTgS8bk4pguVOUz4xqmIM13lv1rxjQkzA7O", + "NKTKO5D7gUpJF+ZvTlPwNsxApkwpJriqjbj9JK/Lnr4JJdD4iieLyqRjIRKg3H41K4j0jTgSXGlIErpy", + "JmXjr1WS+W+7kU/9Vc7Rr9zF8eXI3m7wGqJcaZEeX45OuJbutxY7r63ZjbLwHULM1WEcM9OMJu8TEd2Z", + "m1Ptri7mCru+T6jt7z/SmKtTmiRjGt15h425uhZSe7593XyaVM3Ggsp4KHIN62d5JLimjIM8iwJAXbYY", + "5pyb31YRYdmCMD4RZG8iJBmdDD8eXl8TaaZVr3p9z56Pt6DTbyyGUynScg/+o/tNKO3tH9zShYj96HQZ", + "wrNrqmfXEibsi/fzDZVT8C/ig4KVBVaW/kGBd+Qq+my6XEigAdkKUI/2qGkZwYPJ5M5k8OmoXRt6tvWA", + "ENXCtwH3JS42WLgUXxbYvmB5/Z4ZjQZPFzHustGVLwcK3PvyLAbHMGcRIClbkcfr2xubFgEah0MUS0vp", + "l3PgUz3rvfv5bb+XMl7+2V/fFWfRHd+h58qOK0uojNl091ZM2Lj963ycsMhgfJBnR0KlQl3WaVBFSnjI", + "MTE+Z4qNE/DfAMv8CKlOvjC9sqJqN3XOpjM9E7mCdfJvyH1SfkdRy0vumToXNH5PE8ojkKGZhpDQgNhR", + "hYH1JdhjU8X8K+e2Ljn5uWm/l+EN/hMW2/GnBk0sawxHJzHTG6Go7YU8wWFrOm0l6QQIoxUMBsuXS32j", + "VE7ViYpoBvH6rd7IHAibkEikKeUxYYrQxEimCwK2D9lLgXLUJBjUJFQRWjZPGIdXZO9fjMfiXjm1A4te", + "DbzQSbWm0WykY5ByfSmH+BX1FUpTHlMZE5BSyM1jMd5sKMazXPdJSu9AkUwoRGGSKxSpNEgaYeeNc4lc", + "N5tM5DrLtXewKI194p09Ty2IzDm5nwE3g0ldaHDKazZY0FwwFill3I/Px8tvHtQFI7BngnHPhk/Kb4+9", + "XuDz9enOmdJETAjwOZOCp8A1mVPJqLk/LYgCTRh/yKxfMqEgNrK/RZgkuZr03v17s+zAqR6YLiPQva+f", + "+qFF27FJhoN/7fdmQBM9i2ZgOXizuZZI/ht2L+SUtWl/W45O7JcxKDIT9+ag7M+1czL4bleEJzGr8NSV", + "gYsvPoaY0qmni6HZ5gjMhNjEkA6myT1VJKPKnMp4gV+tjCQk2YPBdEAikScxGQNRi3QsEha98s2a0DEk", + "9r7KB+R1jfCtP/C8V2QHQjDSgugZUzU4WqO4KY0O41iCWhfEexc0Iu5jsfXl3d3yW34MmYSIaojf2ams", + "vpYpEpdfiGI8AnJ4fUbmbwa//DIgHxSQEx4jzo1AGyxTg4tyHYQZ/kfjge+cOOh7Ie+OmTII46E9Z4q4", + "NiQuGvkIl+Dvc5Z4Bri6fP/h7PyYpKBpTDUlekY1uQcJJIYJ4xATwStgcCyiO5ATlkArNBUZ8AC9v8qQ", + "/phvvpWrGSTJeq+R+ZkYuQYb7E+ETM2tDT9c9snRxXGfnFzeDP/39dXZ5U2rleJKrnjkQYqzCdEyhz6J", + "EqHArpnQiQaJB/SGWF4DMYkSZihdzFQkOIdIKz9TVVpkIzbl1LdD/B2JpBYZ8u01wF5uw7S5YSl4uZz7", + "QPYYJwoiwWP1avPAFXFb60WQb5Y8Uxn5IlVmUEq0XvQJ41GSx4al2HNiE0M/mCJcaHuAsf9MDFdfn/CD", + "wlM2sMmSBBmXRVDkvXvqlcEjFkMdbfuEJkoQlWeGhqPA8G4qRZ75jnAukjyFJlRpSU/8VMmNRPZSkXOt", + "XpmJYwTWVUa3NqBBZcanx8xzBke5lBasJERayAXZu/7X8aslA7VyCB7QGEhCc26gsddvqBLzsal10dvI", + "W3MLsM0YoGYpDI5z95Je53v/B6QgRk5F8GF8BpLpASl6KEIlGF5sqCXEyIgsdBJOuXDwPLB6ilLfWZ9i", + "aD8Y8DMnxfN0DNLclHl9QJRrNgcyoSzJJRiKCjGgPGc+sxhkFUnMAnLuGO/glleWX6zdi0coYp09+und", + "GNLsRkX00xrSTJOKrKII1STOZSHf4UpIBpKJuFzZtf3zUddVnWgd/O1tM81owv4AMoaJkOBMnva6sL+y", + "F5EbwBf3HC9aO83RypSgdHHFpoXpmIFE1lARoagOylGDW37IiTm/BVEJi2ANLrFrDBOaJ3pwy29QAirB", + "9N0t//MreVc2rlzCLf/ztnd5dXly2zMtHLdea3F0cXzb6xPz7hsMBqYlfIHI/J0b4Vk55E8WRev90W8n", + "5+emj8N/08eQxyU50DOiFkpD+pMqlm65ZivGqJfc5ZEgxHGl4sZYik+Ce8p0AQwF/pUvE3uFgszoHMgs", + "59NBgJr5TeN+vW87FZLZXpwnlkk9QNXmJPLlcD7tSIzi1qC0INQ0bOWvHhMQzT7TOG6nPjadYimylr0s", + "nAVUeW6Fn8Paviz/rGZUQsAmGGV59Ysl3cUH0J9XvlcfDBnwWH22auAQR98EwM0O/9jOc8XNLz0fMDrN", + "W2u7WOsOnxVQGc1a9qvpGbYoEzyfy4d9u2nt47ptHy3pZ/PQbXk2Uxb7oWvlRf9waKg84lcf5eG3t0fh", + "LJKwBWOH1/MaTCaM37U8xJRGhqYUj+e19imknxOWMu2Tv5TIZWQJupaUca18IrgZQoIywkxw9+69+zkN", + "GSldA/UkaD8CiTptO4f3aLNCF9XCcCeU/sy40tS+dVv0lGzOEphCHHZFoAFNvrU9t7UUegxua/bCnBtu", + "7p3UiNuS6cVnkbWkGPiO/Cwy4P6tmtfs56mkEXzOSmHWJ4eL7LMqH92+l7SkUyjWtzuKqYWK9EPx1L2+", + "Pc/kEEkr3s+b3reN7hsfr4ML8/++63Av1c8xk9stQZbU7S7h1JnsurgjuD1gP5wHceDrzgv6rc44wm/k", + "9QuqvFIDr8SN8Fu8fXaS3FeHa30ABeFbt1ShRogGTauxZPMAYAI33T6zbP5fAUOcOc86vtaMtjT1goTT", + "XzQC9iabPrs+vAgTveAGvez3EVi4X9lvfiVprswbiuSc/SeHZgqgliewduBTquGeLvw0NR9zeBQEXOG/", + "62CYMKraytosm/+yUbQxoLmhQetdfERS7PEMCiPJd4aYfs9KcP6JQu5dTQ7mVEgP+n58XGYVfEXu9DYD", + "Pv9IZVsgC0v7hQl77rmde0CztzU4UcK4JkoUVhoSUU7YlAsJ5LVX6/gYYJNCel7I9SFpO+gyaKTh94zH", + "jE+3XmJhlr2gWYVvX4uERX66EpB1NoCdtV85KlLDSZ8n2hM+JDa9IJRdnnpaxYV36gZGkJ1ndlRvfdoN", + "92X7bLmoDWTzgb6dbhURzu+u7JouEkHjkAh0hO5rrYWgsAs7lcCt4WBCAwR4E39ts8+UTSXVcCN+E0oX", + "KF3f5Exrv5Oc+aC2LwH7F619S5kyPcvHnyORfqZ/5HeUys/WI3DfoAXIz0pGn0tPda8oUnjg7gzGLqDH", + "DbMm8y0XOxQJPHAWM8SGGWicMl5zuw3HHWDb0nf47Lolh6JT4Poi6FRHcy2sA6//+5hGd3nWbNPvse1y", + "27bvFXpeHTM/hoxBUzt/ALvQtRbiIyMErMU9NNBjV854CVkt4yWWW0KTlVyUcQ1nqubV7XEuk7urqtfD", + "qHxITjUdU9XQs/rYtV4O6GxWBW34F5VFvIOH0tm2Vxnws+NjtFltbPhBgbygnE6hUCV7miKRanM1x9Ue", + "RnBLKUvaDHBS6YDq3BQyOoU2Q/xW7+MoZdRmhJub62VvxiP5vgG6JCwCHuAXiZhOGZ+ewxz8SrCUyjvQ", + "bbZ5Ue1hRhB8Ko7f+0cXnGlh/sKYyYeSaRt36RNcy3mqHlTrgJVmMf/sX2kW558Dcu/92VJh6/G4Qsg/", + "QkegtjrWq0pffzxGKjSMrKKyIZepdlnekuPMF6eHAZ0qslxLUQNPe2yBfHKTOrVh+OLq+vQM0lbYdlPp", + "sCp6VLG/hoU+MQSfa4ML5xa3LmMkVOkbOr1hvif1+fJjYd42fIugm7D50bzeZsx5HlvPunuqiBmUaDqd", + "gs8f0AvilPHBZQmLfkM3TRJxb6jIuYhocnZ9GEV1RUY90O5oRpME+BSupZizOCCwxlxFRcPlDe3+ytxo", + "KkNx8cgMN2ER1RB8biLZicebvgX7VuMn1j6KlKFjzSIgpCt1L6TfCq5UgnwkgB/gl6d1ghsOffMHYOCT", + "+F8siSMq48p5NQ3VQnAagc4zPyQdX46OHvPS20BmlACtcP9VL1K7gHcEmxXRzc6PRJkd+T36/VJfaPCa", + "rEecc6dPW2ZfjIdGIC9pY3DF2Jag9I6ewxp79B+CnRAEuA1+4jc31yPfZhpjX0XmCG32WgrimpE7WJD/", + "///9/4jhEUtH40qslLtFyuNbPqcJs3H2c0ZJaYw08HLuxnOeXcBjIib20r1u1S2IxErcRSFBb4nAW3GW", + "NRfr67I71fg+xAF1rO8Zj+11Ko/VBUEZ1bCrPiPVQDXBhxDlUjmN53oLMyqdlk4A2zW/15UOlfj8UyEj", + "qM216pjga0ckZQoUodwGMRFmwwFwKhJRzgUqy1MaA5FFr2RBzLT7gicLv2tzsarLlf3711Rt5UKflovg", + "gu97Z+6Tca6J0ixJSAJ0XutV9rjlezlPQClSm4UtQykwtgxJ3O85x/Aqb2BYGE6OklxpkBVQCTUUXDGl", + "gVslL/A8NdJaVPxs6GtEnSdzDAlMDRXAf6MvY0V8c5De733ZN8Psz6k0KKnMeJVpTnP0faz8clSMX/nt", + "uDJV7Wc3a7mB41Kr1yiu3LwNyjPZlXWGz93aQNbjjutoux2jqniO3Hf1OrcPsQICjt1W7rrBEJUOK3k3", + "6ljj/J7VEsaXOGHwt4ga9MdhlLatlRgM67XkQiMdKvFKbJRdJLHuCYxPDQ+zqGYm6aPV5pandGHIBXWB", + "AW4ESSgxzJhkVM/65m+YQ2HOiQe33M3uYiZcEEMRSJBmE0X2CrMdLbyW5zTJwRtzpcM5GHCwVjd7U+1R", + "wmKjnqZlaWhoNenHWpcNKHBd5x4FRZGZZHOKubSW/5LofGpwvPyHVAmdo28u/rcZeanMObwuR6/86v1x", + "OComrfzo+204cmuqtrPLK7d9s3KNdQJQ+Ms1c94WanDKEivprbtum58LFLCQmGdGHjbc33Fgxf6A9wvt", + "i8YYsT9QJLfoZBrWxuobvjM2XTHq7mbGVBnTEgk+B0QCLQzQuwwNfOo83MsoZosItzyuYqaZwmDcgJwa", + "bPtC0yyBvvmSMJ5/6WOEo2emW26EUUp+uvupT35KfzK4+tP0J6IWXNMvA/J+dGxQXeTTGaLqPYsNT15i", + "7D3Ts1tu9Zd9kqNsQdARcjrTuFe7XtzwNcgIuKZTsKEvNeT3xZaEEeHGoWWBAYYJ9Arc6znE7/V7PGOZ", + "+dsR+YYgb0Z/b0c0//xYjGr+uHEjm39f0hTiazuD+fuomKVc58dVYuCz7zVTA9VY8mP5TYgjkQVsLiof", + "G/rd0ApdWLidRXx9q78Jpc8yfwzv2XWhTEK2cXZdhKt632xC6SIj0vpQ5kttMIyPc24R/TY7uaDZpsNt", + "pPVcPRWfD1to/hFscNPEcM31vlXi9u7P3kTIlOreu17OuP75rdePIpPCZUH7VYo8a5tL6Kly8zS175rl", + "H0OWiEVhXln1lksLd/wG5v0NThQVS3YlNua/ftkaViMBM99ZVsU4Sw3FeuMPpCs1yit8xX4gmIWMDI/O", + "ry5PXPpMFLmUdaKJy3MgLkaECD4gRzOI7iC+5VzEsI+xpIxj9FWu4TDLkkWhTSqcHHDj7hSIzLlCZQYl", + "eFt8esvd3JkUcR6BIiNNda5OKUtQEzxJxL1Zk0TGgZqLL0whN5tQluxjUO3dLf9PTiXlmnFAUXFALoUm", + "lGQJjdBaRiYs0SDfFVt2WhOmiKPn+2rBI7O1OaOkpvHqEyWM2CkXBBI2xbQaZv9kRh13NqKq24cCPbjl", + "/+NPdwGDy8OLk6/2kYjQY+PhjQSuRIIPT1F5e5qlG1ZLzVEOWsZkS6phuvBduf1CFCQQaeW06tfF0ZTf", + "cS9FqJXlwDYg0cjnS4gYkBMUow1pxOvFeNPbnhQ5j/elGDN+28OeYxrd7ZuNU+3Y+z8/ErCGZ3IvmdbA", + "lzGNZbIAvGHLxkuxdDl2r99LgCq9P87VYp0LV9LOrITS0alyULC8xyV8mBtVA3JYBX0MCzT9/te/b3vT", + "LL/tfbrlKPzgiykxACq47UruZ+Z664kB0XFugDO7MC9zUDjS4JZf5IlmWQLELBjFmMPL45/id6SYrX/b", + "4/MUbnufiKNgioyFgW57Azbwkotb7vaFuMUXFjyZKvfZBpRWyGVB9fpFMF5JhEI01PofPDcWsO5A5jD0", + "FDnbMVN3fnV+zJQ/nWLBEtuZOlbTP5nRy7EqPT9tWPIFyGnY02ssKY9mrV07ZuKeB7S9OdfXweg2kWkV", + "vErKA54KK8dQrrk23cYzMM3C6T133Q0HBIWAxtUvxLbbamUBbkTfNuuBwVUBjHH9X7/4s1AsMlCDXyXN", + "Zla2P/ZaZYtfd00rI+73E5hDQtxVlHlR+oaLz1lsGcIdLA7wwUYyymTlncq43QsTHPPC4FL3i0dpH9n+", + "Uuhw0fg4075te8sZN+zJNlWzIp1OmUGiMgNNSJZLQ8FsVjdcxtBdxztU4fpSTFx6jRTVjD/F5u2SBuFB", + "Nz0Q7I2dpXQKZ9ycgAeUz3wpbY6Lh4nLi7zvHO8xXv7s2CyScms0rxx8mYQc06B5+8ZsCkqTiCZRniBv", + "n0iRmqluOQ73k3Kyk4NNsmfFCZvLxKn/7CjKZh9agFT2bsaLW14a81/hwi6N0OTyDRhgsNPHbDIxvYq5", + "yX8PIRPHdtT/JmNIxH3fyjG3fCaMQFWZ0voKpJSzCf6Ew0uYgEQLWLkCr93rI5M6p8mI/eEBgMrHMiRf", + "aJrUFDR2+mVuF5okxSlgdpdb7nhqTMRkS9IkkRohKSbO6Inpkqz14g4yXQpZ91TGxApabMwSphc2p5Jd", + "6FrypArNoDKaMQ2RzqXPKlf5Wj6FqYzvjbBydP2BVLsv00bYE0BpX3DvKdNcz4QvRx7+XuYgqeCb7eGc", + "+mmZig9im5wtEqk5KpcEwcEqKoxrbYuHxMXh2eXN4dnlyZDsLRNTlWlilhmcvKs3k4Evc9yR/YDoxV3S", + "C5qQ1GDX1B1QRDnm/gK9tnJhSFuaiWWauTCcNnOOW8ueWE04sDELs70BS0pWUpIUV4A4rUVhm1+u18H0", + "UqmICdpqXjy2T9yvwrszAaCSvj1e/K0ZXgTO0rniL901WuatC2asO6qPvQoadkdunEpywQqBtRdgqMba", + "DaAvlAOgEhNQwVyDH9SYSpgzkSsyB4nitRnXwjkZ5yyJ7ZMvrh60TX8lwTYgaGDs33LMo1nmqWKc2Lgc", + "ggpgvkiFhKe7vtJvxJdl0j1H27iTlYBoRQa7qls+PD0iP//8898xf9K+S6BE9lAsG54emU+XlItXQbEG", + "X4h0TlmCfJVNSCZBIXGo5Ipzp1mch9AzkPdM+VHe6lQ+2vvzJbysfC7OwN125bLX0Nde7uNir2/506Vg", + "2iJBjlemXUezSgtiBYLqfdCxyLVHbCvPwIJ5Hc1+Ugg8hdRjuIE1oAxswNfS67HZVla8JT0WoyK/4Iog", + "YT1+REQTi4JBmLNtnEYpppAKbmVkg6cZlXplZK0gmQysttfjjzQqgOiqtCCNrAWpMoZC+CkzpQb4vVBB", + "sL1SYZBtPvktt7OTPUBuT5NkgXTEpe59NfA7F0kvH7/G39eZYOZ+fyw8sV5bBbUwIgE+X1K0ay2zTOIm", + "D9xg9paTxYDclIPiGHZENllZQ5YnSSHGF28CImHKlJZ+RJVLWdvneVN+tK+IxCX0C78m7DvArnpJEp2M", + "tiqn1263FNrt+gekVJkte0WU33JsWEA+6mOrbx9Qy6UYyTVXOa5lnUbXjw6YocfuBG+5PcLy7FC69By3", + "mjnTa6WleyMpZNH2EVTswPw6BW6A3Dyckbeq9XdYO22wucIbrxp06L7UL8+uHw0AB6iNrFEd+xVpD16S", + "O2/3mjJ0qDzs8oJsHxzLSLyBC7LkCcfApVjkuOUlLHNhx/A839AGbg82ogpqkHPLb3s5t17it73VlsxK", + "4dYBbAxVMBsv8PjPjluetxD6dNSWrQ1tr3VOYD8sdcZ+XlZwJtu6mk4UGRm+OcnZsc37qLwP2oe9ZEn1", + "IbvUYm7SUWFiax/J/Wg/FItZe1y6jmTPiVHJghwOL9B16dWgjbZlWF7VarCC2VjLrCHOd6DB5LkqzWEb", + "E+6FnZJ3LV9hoDOBQGaTmmV0Uy0LXP/WogPh1W9Yg3+uMz5nW87KwNuN/woerdrH9kM5F1PGNydR3Pnm", + "qoaESs83b/9nrev/bLyLLRYG3NC1azEEBQ2v+7sUYrGz9xtc0RAZMcjve0t/98padmXOG73S+29v6hO/", + "2eWO6xMEz2eUx2Lj2TwWHG4Hvg8K5NvTQ/Q0CJp3dCCUbmU222zbVFUw3wwVD6EURbT8EFQmuPIltrGv", + "SZvgSttcLM7/zjyT/tmMyXnD8gMxCPGh3m7wCdUoBBXo/fgVCsU9D4TwPINqXn0LZr9R5bcN4tdRPvHX", + "fdtwhXGMKsJTNO2r0E0GD02HGCMa5dotpahMuxIyGekdDh4HO4x04ORraeoajnZU9ikzpQWimDEiVbLp", + "FCTELXOMrOabq8b3zkGyQNijnkmhdXBFWtLojvHpBRiAe0B6kvXTXSebG9zbW0iyvoNfm6uoeRI6yyiY", + "wmAVPjeLiuupMtYdIvDrAyPoR4xPE1jNybGeP8IG0TcNF/PVNF7zOtyeOtr/VZrP4w3pBAMg+cB8QOGM", + "H2ubO2US7mliC6NC7MsEsJVrXB7ejIYVx0hPeuzqUjaX1ft2VWHpY1SFHTerChtvzOwQczXZUjY2WOgu", + "FpdCjxY8uhRxKOXMRlhjmaQ8kPNNzEFKFsMljPOEFtXsNmd50jOmjmvFD9eb5Jw7d/dHzen7tRkulHCx", + "hg13gYjUXTh5FVPvQqK/L4dNIEnoMhvjOgyMN3zcmLFgY2xvlmcZbEi1ZET44MjzpbWhMUc7Xkmds1qQ", + "FkMazWldh9zA1B3LrmXOAT16AuhQNqrk52zOKk7q2Xk8OSzOsFqLhJvz0Q74OJEiDV6kX2ASmk0WqAQJ", + "ec1tuuUQZclVeAcbrj58cpUMQU+fsiGKINOHSVJchofrVLOGtcjwgG1HWMPghE8ZDycim7loulCgOzbZ", + "UKgUI4pDAfQRzTaP7nhOJRQPn/ThjCpRJWdD0eVflOlAgdt6h2YpWIbW6V6qkD9vBJjfoRL3PwRuJBT/", + "qguzzYUNZjjM9Wwl40Cl8dbcLQUqVGNCtmiAXNqJqEHaCWy40xQFGy6yItjCmgGfX8Ml2+Qiuq50KArn", + "qtnF8eUolGwpmdycj4KJHdz3EFQuPxuMVC6kvV2KfTvER5qw+APXoZQ1KoFNmSmiDZkpgnIAftp54TpR", + "882L1jJXGmJzJ61TA+YKToW8pzKG+FTIIOFunlujlhFzWZ6zRJUqTH/aSPZPpBRyCCpPvGFdoTRJ1msv", + "kJGo0NA15z9refHWX6lTjHMJ6dwoj0Ns+57FU9APLrZsV2q4EMZTe/KhtYjkkEKLSCThshq7C97K1Qh9", + "YPGJR8rW7Unut3ZMdq62jw47ps1x0OYGa/2aX1kuk1ZbruXgW6/wEAcqTcSrqS5rlU9kkyS9LN6A8hXV", + "7jKu+03/bf/N6/6bN/23r/tv3/R/ft3/+U3/l9f9N6/N/958WrNWl/Hczt3X1uY/GV58Pjy+OLvsves5", + "hySRqXfEJeLuEzXLdSzueZ/kGAjVJ9qsh9Ok1690/zw8OTxGl3K4J4mYquLr0dXl6dmvH4aHN2dXOAno", + "g4zqaObcQvvEMEdf49qQUZHDz7YbnhyfXN6cHZ6P6q0kYFAATRTZAz4ncypVnxQiu+oTeyPqVTHS+dWv", + "uPdDvjDLnkK8b6MxZJ9cnB6S8paq7T//6+Twn4FOXGA/WybEdRqejK4+DI9ORlhymKP3SaHrMmuyJKlf", + "1OvvE6fi6xNMELs6yurBNB2oT1LUypZ382F0MhyVjqamWwLmvxAzWzlV9clbPAQFutaptgQsyp4wpQ9i", + "0JQlmB7EAVvF9oIJBKrw0R7eAtP1G+/gIUe2083VgTcE/O2BtwG8boXOT/6sJis4XcVyDwzUQMkPqWtY", + "EMZ2L9EIIX0Nhdfx89OSgtbF+Dpdf6KSWGE2s9Z3PZl5KQPcIONuKbuevw8+m87fjzSL7hYbUn7jW798", + "6Jv3482q9FDLP14z67U1nnmNgr485XHKNmVBz/XsZJMeCDXLh9dnh+NcwYYmRyJNBX8vdCghpZBKSFZX", + "DjW3NBfptIHGIH8zj4ut6bTPYUqjhbkH20ttbB3YPlZRrPR/QMpWFsOpFOkxVbOxoDIOawf81vQocDQp", + "/fKe8vie1ZSRFRVJuPhf0M4+B3kvmUZ1ld19QG+rZ9cS/BbtlsZzdceyD8PzI/zb3yKlUo9mDGxt/gam", + "umUHVxfFjJIJMdmshjOrzq59e6vaazfYUJ2l9xrkBeO5hkBxsmWpsRalgQu7xQaTBsS/haAoV/Db26Pg", + "o3ylX/3jthO5L4sp8LF5vrasqeAv+euOOSzkN3qcLovmtqCxm56/LbhWpWbFc0x/ELRqr1sVci1GWmRl", + "JJsK12YI2Zvdt1MRRJ7djEQSMqGYFoHE6xK0ERAF31AfKagF8ANmZcYwcK5ToHXXyU3cN6Vffk3EmCYj", + "luaJphxEHjBuZyA/KJDvFxpWC1Ctt3JebtsbNp73hqXwPo/rt7osHZbh7kfIDnjdplFLHFUUaMWsIaqd", + "88eI02x4eHYcNGAa2f2Kn4boV9w2H8LaOnbxpsDgI+cz1EL5HMl8fLQB0dSCR+HvGw5xCyF1Z9yWKq3c", + "TQvKdFOvarDijipZSuXiSCQBByMbsLmhSXjiD8pbLH6jw2RY1Z9QpVdto/Wvhbf10YzyaXCGhPG79gn5", + "V7yLN30/+ZJtbBJcWdvgAtfjky9db1H4eGSAyB78e6AS5GFupVxzjr2ZlUwL1HJJA9gfVlJagljGzL6/", + "fsWCMBPhnBk0Rd3jWl6T4cnoBqORJ0ISW6CMHCUij4kt30HSZekdI8RpdMt1DUe2yeH1Wa/ifNB7PXj7", + "dvDml6LWCc1Y713v58HrwWuX+wW3ePAZ9Tvv/uw5MroasaVzyV2qMTtPIqYYj0qosknOGCcavmhiy6u5", + "NbrEn4Kfxb13vV/BAKJCFmZdkHHKt69fFwdTeOTBF32AYyLmIz7XMtCMGady4XFHXjvTq3+arf/y+k3D", + "KZrV+amaczyTfuDUAQTEdvqfv+X0p0KOWRwDEv+/NT7dR5n7zBUBLuARm9cwCyPTqjj1709fP/V7Kk8N", + "QcUo8nueCBpXQA1zZ2Iw4b97NgK698mMeUAzdvA5hdSJXxuh1zYjOSbCcHpIl6zHrRnjC23M9TjH/C8+", + "GD7M2IWdcSsg0wy9Ak3vg9+VaH3gVW/9FsD90GkfBcS/wSJqgP7L6799+xVcgJ6JGFM9HiaJuDeH0QbW", + "fwW9BD8HoM6yuwHiaVmPywG8D0Zd0S7LA0Hp9yIOZnNfNmGwVrDrQTDeIuNrGL5ff/uLfU9jUsmW+hzA", + "++/ffgVG+k3Yimi0FajPMaRbFll5lvXdCC1gsgDtC2eq+YQvNeUB5muhOmjuoPmFQXOdUh/8ad4JX61o", + "koBVy9bB/Bh/LwH9soiilDQFa6X591qmMtOSuBcNPkswl2P5KCnVRcUTyMLp8lBXhedPD8Outx16PR/0", + "+uXbr8AIQafoPdZWBFo6Dgjp/AEIXcM0Ml6QUje/zj62ikIdTnU41eFUK5zKcp9Elnc41eFUh1M74VQp", + "GGZsH+PyVV0qXFVdpWJuSxyWFUcrw4dEyIzd2KHXEOVRTto6wtGMDdyULtVDCVrrZ47fbTZdLdzRreH8", + "1+eiT3sOqNnp9F4YfTh29GClOLCjABV8rwirfkU1TZIyAS/Ey+EU2btnelYkX6ORzjHZpkGtGVUzQDdT", + "rwBcowidyvpZgHdrJYSBiyUwhIGrUKSt5Kd1oYKKUMLhvsJQsMgM2vbKLOUVLyA0h8iKBVDSe9dxT83E", + "PbdJLAWPYB38Cu3dN+NI1qu8MUcqaiGSpV96x5M6nvSMVZc+i+43WMAj2HWPXAH9OvUJkbF1QbmiRXXv", + "0hVQQdnc1gMvKrSV0/ykSKV1v0rg+uTsmpQupCjb1/K1kMKb2Pp2eB/DBX1r8h5eysJP9h5+ZKJqT7YB", + "UT21peW0cA+ljpx25PQHEvEtHjQS8QvyVcn85RfLLFU0QpltWtSFxDTcnGlGE/aHK2q09PzFxNQAMcQD", + "MiwK82USUpanJGER5qm2eff5/rJsRypiLOzgFdLeu6U+DTUJ5zDzYUrlJIr4g8cmJZ0S78k8zF6gPDL2", + "g1yB2wVurCH2/rIK0uY3PUlphkXRksQ7WaXUmPN7K+JN72Bh08K7bkY+GAQe+m6dR0X06vNgti/wne29", + "ohYAURFWt8CFQpLonTAAEo0uv4kk+n4JUI8pinYg9+IsG1vgcN2iEYb/ekDUBqu8G2K4bP8cOPrLpVXl", + "wWNta6fTY5IkIrpbdyptcoGOiB0oTjM1E1tdTtdu1BChUdm5OTUie0VZLFelvCL6vnompOoHgLbvT6Ze", + "rvRYYl+JHFiHcA0ZF2SvgqMG+17tioWa7oiB2LHDvg77fhjsMyJLBcUMajClWaTInmJ/QN/GpkUi57pP", + "QEeDRkh3ALGNSt7oiu66n5i2319XYnVScegB2+lMnqHOpA2kGzCrmTR21VS0cUJ3g7zMN2THGv7SrMH6", + "zK3q04uXbFHdUlVeJU1R50ACVultyiEM+gxdl++DRbuxpq1I4jZF3AT2sVmc6FncJzZ3ji2tWRYat1Uc", + "gdio8441dT65PxzlsWiBdbpdueOCChXY0YbctFS77Kps6dh2hzzPRJ+y1KVMhCS0cEiMHBa1QZ6cJ8KW", + "E2rKqj/YHh3idIjzkhDHgq1f8yitLKw0TbCS+l0z5WOBQ38W+Pj1YCKSIhNpO0506jp+c7Tqr1Uadysi", + "Z8f+KSo8+gHTHGNueXP8ZnSUjV0p+8r4OPt/ckCjl5veLaYjFB2heDoO6/C4ZqvYRTatkQZZujg01yst", + "6QP2flbkgWhBJsW6HotQdNjbYe8DsNfiCdmzOPaqKhwX4Ljy5JRVx4pdEFvlY0su9p3ia1+xP6C9CDAq", + "xnEP5JEZ5S8jD5S77+SBjqI8PxuqVVkZxEYravnyLqHWASxtJiZElO8r4PF+mZB2o/vj/Qz0DGTVx3FG", + "FcHOxIzD+JRENKNjljADn5XA2IAX5BHlI+Axlil9Nh6wzyg14dL/eQbRHWGTldNmihTZpDekIGzo9mzu", + "dZInSd2BtTDG7Cngimk2BzKxkUMpVXcQIwxi5EJZX8dWBgrFNz+OvzNNkqsJok3Le++vlep1Cb03jTNl", + "epaPP0ci/Uz/yO8olZ8jTOW7b8/qs5LR57J6s7X+r9HlT889xPqF5uT0gWsFHRz0f7KVSKLZOgJcg5wI", + "mSqCtYpICbSK7NE47hvhLKFRpfxVKubwOc/cP2Jxz18RwQmWMyWu4NFa4I6Zuw7+Tx8GiGWQNsQA4ncX", + "/7fcdxcJ2EUC/kAu84h5DrebEIncyyORBFgmabichACbdFyxwg0du6QSSCYBe8X2+Vf6CdkxXgUilp+U", + "ZOzC2tZhI6+kQbEH4bjesyUlHRo/J57/gk06lnk2FULqMvlBbHOKhQQT8zMocnw52peQoO9oUczYuegY", + "6pEJqftkQpNkTKO7PsFSewlTWlmvnihX2lAbriXbKpkcf4tUZJcjO9kG0eT4crQaYNclLOjElL9AnQFH", + "UdYQYAs5WSZBORg3cqeolVt87/wpngjxlxMNjrGWL87nAPYfo6tLLwnAlpacHeQc/0syukgEjZ8v8nch", + "/rsxUoQIIiQpbpqSGoS6ItB1LKjUCw0hw5r2K6CUWnbpIvJ/CID6FWzuxSiXErgmlzDOE7qJpjaDJg6R", + "bkdcj1ynpuT1y/6CponX0TtcPctt738fXpw/cWRRB9nfOxuKhSeiZ0wRLmJM1FuNO6oTzo/Xl4SDvhfy", + "rj28Y+KVluBu+zxhUEN9f2ViSCcbkD3LKi5pCn3C1DmbzvRM5Ar6ZOZqOvcJy4aUTzEPZveM6BIWPWXC", + "osdDxxiyRCxSs63t6WqShCzbkxgmmKOslr6oNvp+ZXTyz49k71oKMgGqcwkbrHnLAY4rq+v0fC87eXGU", + "5EqDJHHtTgtorf4aTmO8zJdnsMALi8T51zwAEH0saBUSH/9Rm0kxWM7if7569ttxm2evtHox1c5qPGYd", + "X4PoupW1eMPPA9Uuqmj9GGyl9D8O4XOTQPcK6v2ICdOeBZq8vGoPbXCk3zAVoJ+pPURy6uC7g+9dcgKu", + "A7cnFeCa3NY0OfsucF56LzxHOP8eEmGR/6dGfzpx8HmLgy8v5fljyIJzFoFqYzQ5dl063fLLVlyhAsBn", + "eLPRBlWDSq5Akj0hUV/AJoTGKeOvNui0+i2UyFV4+jYmafucamaTXlU5dzaWv5AC1+IDulZNXaEuzFMV", + "gdRsYrYGagfNLsL7wZ8s/nqQGUGlPfE9i69Nx61CFS7fiE0HoXA6Fr/Ml0NnMumi7HbH+WusC+vHdi1I", + "hEFYEmg0szFui/ZYztsJVbwTqB5iw7COr/X7PL4cVVxhH0VU4U9biKc+2eXohGu5CPnMmq0tEFqrVvju", + "gflMSfXLNDb4MWoncnjw5x0smmW6XUW6f8Jiq6xTYsQdNvaIOvZDVzblL1HwOQS5ZFxASJghtGDaHWR2", + "kLlLQZ8HQKfT5G/XwH9X6PzuIlKhgq/yrE5A6t6yj1pxNOCHu7ucBDHT+y7+oZUr7knM9HERN/GtFKlm", + "0mZqVLOvToX6o6pQsRxG1WDgVaxUsrG0RYsp6H0OX/Q+y9poVX4FfQlf9FnW6VZ+kBAfAwSEzilL6DgB", + "cnZNaBxLUKpwL61D3tHZ8ZBIyqfto8kSMW2lwTs37Tswe/lg5sKrPl5fYqy/oVyJvdt2ANTWtOMsOh0A", + "tVRXFQnTDPZfHt6MSJQww4NcAB+6nitCEzZvTwSyfJywaH8HL4lr7PncfCWegZ/Ni3aXsPBAGJ8Imbra", + "RWORWyMEF3wfA5oh9vtVtAY/CcqCW1OoG2KHjoi0JSJ4bpaCLKn/w+KHJShNZdvbwy7d/e1wf+bkVm+w", + "4N+Ux8RM7pL3tL5LnXMOSSv6f+O6dHe5s1GXRpiEtE5KdXmuW69Q2l1tujFZxmlV1CW+zS+bMChVkcOr", + "S5tB4m2vK5TWGVrbGloR0IV09ntiwIn8LsZ1vlOFdATX7R4LHVB3QP3igLpKtdsUxTXdmwSYlAt50vCS", + "9ljWIVlngdrJltx3yRH7Btvi0uvBi2+e+LCSl2wRjzrc6nCrw60dcWuTq0aHWx1udbi1K24V4mJM1Wws", + "qIy3JkkqW7oE8VUdLpZKNwdIGQeJJXdyGwU3Ohl+PLy+DtV6sHzyuFzEs6t1wjSkqkW+5mInWC+ityxt", + "QqWkixdZ66TLTLxjtZUlwiAwbchJHDN1t005eoxtutpoL9wAhqnm3FUW8DDSQtIprALEgaWvVTe2tVNJ", + "qbaVNlzZRIhxdEuQze9TNgdua/djsStiBx0gC2YSFMmoUvdCxpZzOIo+ICMtgaaKZFJM0T9E5DrL9SCU", + "VAzh067oiRzolD2mgZ3EzBfymbMt7Em4lezgM6fhiz7IEsp4y/yy9uggJmYEd27E1SHDi/n31fXJ8PDm", + "7OqSjD4cHZ2cHJ8cf/ILZKFFfJs0Ek86+3ZW86TTb6EpTzr341RONTBOLZQLSTIqNVuxtHooCw+nwyyr", + "e1F0wE2EuMuzMpeBpSQfhudoDZSVUngSlEjmEJOz6/kvhT9ZSNTjW4ummym0KEYNlBHNZfJt6xQ/umS5", + "VmK1jWTYFaMJoE/Vom3AByHZFv/8MDzfVPsx5mof45aD+PERpGGxBuipxoGZIpGQEiKdLCo1PNdxJowN", + "6H7VECVsWLXb0TNBjB8rlVmHVw9NBlKC6EpJokYoKKI7kPvO62Rr/MYxNh+51k8jdNolDWpT1dLfeAVA", + "5zbzCLlvHi6ElouwguhzEDM7OW+HaHILgqVL1h6uS8F+wu7glX1XuFzpqk/mIslTKKqaFYq5Wl5qHK6C", + "fDBfyZXuY1gnc5coeiO7GqEvGcZ4MU6Gp0c///zz393Lk+y9ff36v/Zfv9l//fbmzd/evf7l3eu//Z9X", + "AW42kSLttSpMf8LjR5lZi3bzXjDO0jwliZiSBOaQkL0Yxvm0j4rSPlF5FIFSfXJPJWfc/J5mQmrKdZ+A", + "gYvQShIxPTcD1tYTw4QaoHvXM8P3+tsXeJonyT6+SBVQGc2IBpkGprQt2h3A+9HVJcFxCFXEPM2Ja+yf", + "o/izxRTXdMq4q2SRSyUk2btCYfnsmMzgi5svdI4ZxSiWJ3wjdNq176xdszTMEsMJSzRIzFPEY5KVoFOh", + "gRegJYuqyR0ndM6imtvjylGBrTOJZJXiP7EYvO22Lvf33UMZS9BrgxiUE5ZaSPQR2FO3gO0Pgn3gkYgh", + "JoppIO6FMDHrqy4nhHyt3ghriFgIODTLSCpiIJOEToO0RM5plj0i5olIg95XKODUgbHQmPbGjFMbPbxN", + "Tmry/AhP+B2eIU+8mF2eI0+8pEeKS6si6danyETICFxh531XRTWoiL+RbDoFqQglKeU5TdxLHWcqYy1d", + "4Vs7mArp0U/NxHajH5bFW7sHemeN3N0aiTBVgck1SAyiwRT0/phGd3m21T/A8D3blLiy6O6FYmXBCUtC", + "PO9X0O/tHA8E9Sci/x1wd/qvNozGYYGD+KDVfypFnjUrTubSM0qRALHdyB7+cXZMbvPXr3+G/0V+DpXP", + "+NXO07GRl11mbFpcYwFQ7oemRcXWYMjpjGhq4/sykClTCqveNSojVoGrpykRYdeP02xQtuL3pZYzBk1Z", + "orpkVV3J+x80pSgir48O1BkL5kffVJjMhgAZ8rBGGgbk1CARYRMsXaAIlUCUZklCqFJsyiEmWhCmB01r", + "lFlicRZvU2xYbH5YsnXGNUxBdtnWO6R/hinfXxDZKXPBBklOi7pY2OcnZQUOIdvIG7n+vhTkacQbe0jb", + "xJtTBkmsDLXNl+qgTrDpaFxH4x6FxpWlwLaKVWi2qYRWbyl7mUmYM5GrZEHyLBE0hthafipBOb7n+plp", + "0ySyDRuilsHS1D3GoyRHL2P4ooEb0vrquxS8fBIDzXc0QLQiM52x6EcwFlG+grWbtOTYYJvrzJlttAWp", + "L1E6ssn4nMePJRrmucVVBpEO2FlZhW48D/dPM5ca4L7P3NI7x4dHh1Z3tEsPsVUmE/T4smB7kOVJ0gh2", + "r03DB8BvZvt/S+B9uPukWXTNdbJzXmxRJswc3gpgYul7SiRMmapneN8EoPtsso/Pxa05YZeweja5cD06", + "oO2A9kFAK3iyIGxCmCZMES40oYkEGi+MmK+Aa5KIiCbJZnDmc7bJjeRXVyKzsNg4FLF2jTtYoJlGZNbF", + "MFkQBTy2DmU4sA0Cc8GcmPmUQEpZErLfnNnlPFGxEQVyYGfYUuDgkkV3pRHKvA8IwvmzVXN0KoZnomLo", + "fBUeSOiGhnLFBfVIGL+rUC+0+1SI1+9ivO2F8w/TpPOh3sm6byaM8wRi8rs9xUC+FvP1YGnR2xgfZe7D", + "qvB3SWcZScEH/xDjGvnubvflontpzfldjK0UjvU+hlfhTN0+4HMEYCvk/Qq6A7uuWPUz0ec5tyAUMhMx", + "Vea5R4usKZFBiS1gL3PeCOyHOe/AvqO2vQsMBEgWRNvgAEd3tSAy59thjW9XdDho449Q9uavKHW5UmvJ", + "grjjbiJ5KS2yRmRgZBp2dKCjAwYQCK3CWBjEEqb0fszkFsQ34HvM5PYobEz+44zDLmD4nVVUhWJkXY6t", + "dmG5x0xCpIVckIzqWWWqg3Aorp51obidxPekwcBYT9Ou3Il7cQGoG1NkIRamLjR4OyYWQcQdxP4AqRmX", + "0ZoWAMgdLOyjQc+ASZLQcb14znoIeSKmjIeV/GYBwLU5E1T05wqki8SoKsILRX6fKNCK/ONfNyQS4o4B", + "EbzIJRFS7J/jCp5Qr48TbFHrYxsSSYjNbulzjsjoMk+9iIxuHwymJA62C/wzx1hHPpHroHfeOb7883qt", + "ZcTA8YJECVCbL2KJophqBPEulNDw3M74XGD5GUUnr12cPafAzaVU3oFuFg5p22YJjYAokcsIqjS6smXV", + "J1mSuwy5M3EfUeUcEIoQ5UTk8SBwtRduSR1nf/l1rzFTSQVsEhuVUGPl+LkKktAo6D2TAp1wqwnxnTPJ", + "UsdQoSkQI8kJAR08vyT428cxKP4is9t3bPcREKzGSYt8ZAEyD3K63XJ5ga2eNo04zrEh8Aa/PyB9eFe9", + "pWNMm+wDCF5pnmiWJVDJ0K9IrowUig3k6WijrqKZmmKpothcKkmkKd1XYBoZLpVgKcJJ7SmMibm1ZBDM", + "zJ2Wk3XqvUeyV2BAwnQqYYr34k54tazIuioindBNAeBDSMXcZbB7e3qILoY2OdaymgSS9D0ap4yTErQ2", + "xHlfTOhTah6MnPH29BDLjW+g3aVPoZPDcBc2pzxo3KtNjdcpJJ6vi+FL9qorYcwp+Nblob7/XbHqAnxz", + "dXNd4uWa0mK1EEMmxZwpJtDSFM46X+BoB+ovXPK2sIKA4ui3D9D8euiPNGEuSN9CmRZ3wP1wpgUxe0X3", + "MZRY9ic00ga6a5qykD762/AEzDy/gScsN9kR/h8QG7A4xwLxoLjk0BOUTQ3a7M8cXmx+idrGvwmln7bC", + "gFvVjTBTXYjYCyfmKJHqm3+MSCakXvPd7LJDdG/Vx36rWtgkR6g0rxT61IIYLCoKD2Au6E0RUKnIeQOc", + "w1ZPrP0xc2zS/pjvnfanw6gnwigEL1pR+2xW85jmW7U8tlGnWvkB/FDwwiGuqgU3AogjwAd/un+cHa+k", + "/guoay5t88ui19ZIaUfoQ+m1eGWgF1iDrIPbB4YWuaDpQh4YLyykBAWComLRFtJ2WTTrAOUHIXB1QPEW", + "pupvlhJrMPFkzzLMKwxurmtXxs2ncXYQ/wgl37oHWYdGbfIB11FpM7W9L8ILtqDWfcv4gscMJ7imqHmM", + "a1EFuwYSrJdBE0lsToummN7F4neo+hy2/bZ1hrvAhb9y4EINsUvw2yT3359xpanN4OXX9P9GeZyAcpp7", + "pSErCsAw29UyrGX2yJhqOqYKiAKdZ32nbKzpGW1hSWsWRhNBwfdCNoDL5UKfhl+nlPHBcpaQW/pZdct4", + "Fs6K/ky5dFcS5vk7pl9LEYFSiLNsFb42llfiQrNJ4au87Q1Ua7uFNzerlInWPscPq6PvXI21434v3JOz", + "BgalMdjrvFwAdR0uA7B9IIHGbQB8CDTe1V+tOjPxgL0K5fOL1cuT9bpnXCdvPiRLhbxbQXqqiLTItw3D", + "RQacxc0KmDnhEWJylQE/OyZHgnOINIkSZl57NekyFGt1ZSd8dvERDPXzja7V7v4IN91bxktQKeniRQZQ", + "vMBcaw4CLeRV5TMH0E0rqjWA5NBzqALJT+AV5YE0DxRVT+GJvUi+R0jSyv5bYVZXyqSr0bZrjTZepy8+", + "8lJnoFsLtRV++suhN5Gc0ugWMPla0rO9jlKdPjysntLzs/R22PUM5OZdTMwN0Ku/rTSPYnyawE78uyqI", + "vlAcemnMuEPVF4aqrn5OHfhXXUGqsnbuxVYM1K/XENxJ4s6fB8Z+LznfFjiLSSfvd/J+R+YekcwVlQNb", + "CPxFVq99DEQNm2xHtrKHt5wH0WIZ08om7kemKjq2kNbh2g2HIYpPGZJVm6hN/Q+7mclaJZMuZKvLYvIg", + "G60DwjWcCoeJZfUMzCsqghlEd1gfnZIPw3ODfhJoNMPUgdWwXEq44Pt/+/KFFOAaeFJcN6hT9WF4vg88", + "EjHERDENOLUWJLN9fTat/7QSVPrrhEjOWeTSJ4kYyCShoakUyDnNsl73/u/Q9luV6sJ0fS7UPehlIaNE", + "cDA8V1Opt1ihh9h46Np2/gwtUx+YU0Mjy/DInCORkAoNxDmCkrSIUQq7tNmqZyDD0tGRi0VXVgaqlUmz", + "uXPoeu20vUqZo1chAWlYzP2EslExxxaxaFjdQFG9YumjV5ySC/rvhKOOyj5EOHLAZO2a/owlS/xU0DQ/", + "Nsr/XYLsHyWpDUYmuuRT+FqbY271rXmo1jnvSmoOWyJFYRV+GsEkTwoXZVky4gB8PQab7qxKP6TL8C6i", + "C2YKRtCrQLTVrKwD9L5r2QCuXY8iIRlmTUhpNGMcyB7Wky0zz9/PgJf1QhhXLAZCl0kXXm3GhVGx+A4j", + "ulRmD6f6JVJUIXbjY0vkGlRbp8BMii8L4voG4Lv4+HKd/67NLnEfR5aidA6A38UBcAXaClh2PzR1/6uM", + "0szprwLBT2UMXIcwz8vSu+KXbwD07L0zAnZOf9/E6W+VIPioSp1DHvzJaQrN/P7CpIaMF0X8dcDdzxKd", + "S9tmo3XB0oVqNPdKbhf7pXP260zr38rZbxtKNfX024g/TCs/DlXlzheJQC+RC3e4+hK9/WoYtuRJPsm6", + "sbNfe6ZnXf2+N8J+T9m+cPaTnYzfyfgdhXtcR7+mAr5zhNlmHBsVzbZQqQv6haV5SniejkESMVnqgot6", + "LLnkAaechKVM+1xyGNcwxaJdXfbFHyyp3hI8NiUDK6D04M+y/Vn89aAh0B4t+2xP01Ckiz47JkJu4LdR", + "bdAuf+hfBoLPuMog0ssH2yokb88kGgBnmmuxnyMBP/hTaapz9bU9iB/mWlguMMIhvj/I9z11pYuNErtP", + "smcGMdNPaKLglX8BqthQh25/GXQ74WhoFpLETFmX5Qr02LJFqxi4A+5FM4ju3KjtcQ5drC3SdRymA/mH", + "JlY00ETuZ6Bn6OdWAsJPirCUToHMqDPsgSRzkIoJvnTK2AH64Usmtnobe+D+xPbrQL4D+QdSeQSkKqyv", + "qNEQ4JWL8IhhwjhziqK2sJ6IqWoP6edi+hwlqfX3diKmJGEcHuW5vZ6RmCXaFshXRsxVQGU0c6nqgqE2", + "pk27xMc3LAWlaZqZTUxARzM7Zc41S0LboUoPIQI2h+K2WsxozTBE8GRBlI5B2k0G5gID4Vc8WfgmGQuR", + "AOUdWfoRnMps+WALfY8mbKaU0ykc/Ekjs9SvQQe0Q/yu3hGlRdYn6ODWL9wz++SOJUkfo1bm0CcZzRX0", + "Sc7dPyTYfOF9kheCaUNad4HLs5M/S5pnlpcC14QWa/TMV34LTwU8T9ExUAsMBVz6Z7t/mRPGH8wR41Hk", + "GBTpDhk/lVnZ3TF/6j9f8aRLwPmC4wdBToRMCSXpKgIQIyA9BmFaK80UNyvN5CEiK9Wa4mdISJoWiHqh", + "b5EO2V9ykSpNo9l6kaqJFGn1lbRDLaIOVzu9wQ+DJ4fajydabMOSZpxwB01BpdZXpxXroPtRjOUFNGIk", + "q55B5YeKxszmVeIQaYiJFjtAPa7sIcbHEQ7wbA2PBRex+4z/MsbHThR8uURgBNqAZs4VLIuXMyVc3Z7H", + "evotTZ9tpcdnZfd8suKa5fpPhUwDQTlug8423VXV7KjCk1GF0s9zFfV/UkSB1q500AYqoPMsnLbIKZsU", + "ChvANZNA0ORGE1tpjzC+9ICKaJK8K0vxuSJ8/UrJvT4Rmc2HQo4EVxqKqmNOXrEl+so2tuPh9RnR4g54", + "WbBvQK54slhNP7BMg2AkIMbJsrIe5oEbhGJcR3gGT1jiDycIJU3Cj0/s9t6Rih+YVJS04IrDvpoJXWBB", + "JsWcKSa4NcoG0x+olEq9H5tVbpbzTbtjmHRZkVoHG40uDoc3hGot2TjXVc8Fa048vDlE0nf58QJILNkc", + "NiecU5xmkrJt5elGRbM14uY7kGUTBsWxmBGGh2fHNnTlbe9rVz+uo0IP1mUIV3wXSAFf68XU1oF/m0K7", + "A/YO2H8YYF+l9N7cCyEzrOvTJJ50ZU1PG1m6GyJ2eNjh4aO8koUkcZGlwY+Lnjjw1vynw7oO6zqsezSs", + "CzBCn9fkpieQwcpmroxPiJt9v2cnumjnj+C/uOAReiLLfNzr9ybsS6/fA+6CQVzc1FM4Jnao/hdMMTDM", + "eRWjnQvingHCPkEY7JMJ+9InFgL7ReDeq81obs2r23Jx6hmQKJcSeKnuckbcZb75Go1Bf2mRywgI4xNh", + "Nc1WFYY9g37RS3NvlxYsfna5kmtathogbNR45rEIGz2GsG92DFybTYFalq66Z3pm/mKVWk9akKmkXBNI", + "YI6JbPbM8K9IBjJlSnlrwxcio1nHE9ZtMONvqdlQlL1CNaRZuNvHszZDdFjwI1TCObEIYzAIAS8VMYRr", + "OOQcC7Fs9Uz44No9DVq5ojCDCzNHKTr4wAVXQdwaHj+RVSdx/cUfVw7AKJmwBByH2yRY5VkiaFWN6Gd+", + "H7AZZrWzMeZm+KJ+o2OweyrPMiG1Ir9n0z75PYNpn2R82idTNumTcZr1iZpP++QexlmfaDaZ9Amds0mw", + "iJGdtYnm5D1VNv0dMizkzNgXYlzpt0iKl+aJZhmV+mAiZLpfZIJbjlbPFIfHuH7QZ7XTtZswjzYhU6p7", + "73pjxinGmq49Iiv7+Lcb/ZMX6zsngi6h3YuoevKSdVwGb0tquenRYSTyBkUmSIJGowk6fGMf++wovaKK", + "eH3fa/WDshnUWibns9M8g7x837XUhTm8rrxFR1eeVchHruo5Ee3fTet9oNaCRhGKikhGPGUmjSBlK03u", + "j6mCmAg+FlTG1m3ML6+5VT2Z5sJuY4vuwqyidAotCk52WouONjSjDd+5ZscLTkxWrSCyUnmzoE81qefg", + "T+4q5m8sHmIdWAztqtGt8YIU3cM1Q5AiXS6bbS5KboavjOl7Mi6/dtVDOlLzFxVDyqImASzfUswE0bgo", + "BF3oa1QGEZswiMNYXXnMvHSU/h4VB+xDpnu4dBTj21MMW1oFEb/Otz0PGKqjmU8DHdOyUH5BPFQezQhV", + "BFLKErTdS5F4qqmYIZ8V6Xii99FJzPSW19EpgyRWVrnsInO7h1FHe35kg3LMdFhWKV4kc5HkKRz8af97", + "2dir/iO2/1j22kZWTJuidrady+Cim8ZLZebVsbv8Ln+hLF9OynZB3A5a1r1i18K3bctt2Yk+ulYdnPxY", + "RXPm5b22Tf5WhYgnS5VhJ6lpcn0HY5st9bhdvozObebbqC5raBQis4mYikbuyEdCpUIVPjKmm81Wf335", + "a2kcXqPO52b0rYCN3Q8yPq0f6nZfkQAM/63pDN8sd4F5NroDTOyReO3oMkoEhwPr2X3gUi5v9AgcYg8b", + "0nRUpGjeleht9awbQirKIpbW4GZYeJ+YntbnvCIzdk6BHXV7Ouo2PDKQj3nha7Uf7e9ehKoaZja9hqpI", + "dVw8aJ4Mqa7wyxKbzKPK7qr2oOpw6Rni0i7PIL4T6OZptukZVANZ07ZLYtPqbvI0QylnkidJcT+rSasa", + "XFPClLbXqpre1nmlS3dprd+LNVxSZA8pKOaPXWSAhW76hAvz/IqBa0YT9arZVSo6byF7jegcuutrl/GT", + "zgFxbnd0q2TzzH2XlNfu6EPVTvCU8rHLjLnk6J1g3AnG3yJNJifwhSnN+LSljCEBI5MbMS2b+LpjVi/d", + "jD1NxJiWwo6WlKuJCy9WWwCmhA11QMci10345FXZ5xC77JDHBVt2xLIjlmuwb1bz5vukljhLswSrVEHc", + "HgddvC3Jlfl/xifCld9zCoA9LTRN+iRXEPfJRAJsk17nE7Uk5dtw8uNELWl5h4x/CTWEAbuPpyNL5x20", + "YawtxJukBZzCoJz1Bchl0nvXO4hQp937+unr/w0AAP//", } // decodeSpec returns the embedded OpenAPI spec as raw JSON bytes, diff --git a/go-sdk/version.go b/go-sdk/version.go index e2300ad8..a6b9bd63 100644 --- a/go-sdk/version.go +++ b/go-sdk/version.go @@ -1,4 +1,4 @@ package cosmossdk // Version is the SDK version, synced with Cosmos Server at build time. -const Version = "0.22.13" +const Version = "0.22.14" diff --git a/package.json b/package.json index d2905c68..d488e6cf 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "cosmos-server", - "version": "0.22.13", + "version": "0.22.14", "description": "", "main": "test-server.js", "bugs": { diff --git a/src/index.go b/src/index.go index a8fdc85b..4a871120 100644 --- a/src/index.go +++ b/src/index.go @@ -202,7 +202,7 @@ func main() { } // @title Cosmos Server API -// @version 0.22.13 +// @version 0.22.14 // @description REST API for Cosmos Cloud server management // @BasePath /cosmos // @securityDefinitions.apikey BearerAuth diff --git a/src/pro/api_deployments.go b/src/pro/api_deployments.go index e51fd2f4..591a24a6 100644 --- a/src/pro/api_deployments.go +++ b/src/pro/api_deployments.go @@ -9,15 +9,30 @@ import ( "github.com/nats-io/nats.go" ) + type Deployment struct { - Name string `json:"name" validate:"required,min=3,max=64,alphanum"` - Replicas int `json:"replicas" validate:"required,min=1"` - Strategy string `json:"strategy" validate:"omitempty,oneof=round-robin least-busy"` - Tags []string `json:"tags,omitempty" validate:"omitempty,dive,min=1,max=64"` - Storage []string `json:"storage,omitempty" validate:"omitempty,dive,min=1,max=64"` - Compose docker.DockerServiceCreateRequest `json:"compose" validate:"required"` + Name string `json:"name" validate:"required,min=3,max=64,alphanum"` + Replicas int `json:"replicas" validate:"required,min=1"` + // Strategy selects which PlacementStrategy the scheduler uses for this + // deployment. Empty is treated as "round-robin" for back-compat with + // KV entries written before this field existed. + Strategy string `json:"strategy" validate:"omitempty,oneof=round-robin least-busy"` + // Tags filter eligible placement nodes. A deployment with Tags=["gpu"] + // will only land on nodes whose ConstellationDevice.Tags contains "gpu". + // Multiple tags are AND'd: ["gpu","nvme"] requires both. Empty means no + // filter — any node is eligible. + Tags []string `json:"tags,omitempty" validate:"omitempty,dive,min=1,max=64"` + // Storage lists RCLONE remote names this deployment depends on. Checked + // node-side in executeApply before docker.CreateService runs — a missing + // remote produces StatusFail and flows through the existing fail-streak + // quarantine path. Not a placement filter: RCLONE config is cluster-synced + // via constellation, so every eligible node has the same remote set. + // ${storage.NAME} in compose fields resolves to the mount path on apply. + Storage []string `json:"storage,omitempty" validate:"omitempty,dive,min=1,max=64"` + Compose docker.DockerServiceCreateRequest `json:"compose" validate:"required"` } + func DeploymentsRoute(w http.ResponseWriter, req *http.Request, lock *sync.RWMutex, js nats.JetStreamContext) { utils.Error("This is a pro and is not currently available on your server. Please upgrade to Cosmos Pro to access this feature.", nil) utils.HTTPError(w, "This feature is only available in Cosmos Pro", http.StatusForbidden, "PRO001") @@ -29,3 +44,92 @@ func DeploymentsIdRoute(w http.ResponseWriter, req *http.Request, lock *sync.RWM utils.HTTPError(w, "This feature is only available in Cosmos Pro", http.StatusForbidden, "PRO001") return } + +// listDeployments godoc +// @Summary List all cluster deployments +// @Description Returns all deployment definitions from the constellation-deployments KV (Pro feature) +// @Tags deployments +// @Produce json +// @Security BearerAuth +// @Success 200 {object} utils.APIResponse +// @Failure 401 {object} utils.HTTPErrorResult +// @Failure 403 {object} utils.HTTPErrorResult +// @Router /api/constellation/deployments [get] +func listDeployments(w http.ResponseWriter, req *http.Request, lock *sync.RWMutex, js nats.JetStreamContext) { + utils.Error("This is a pro and is not currently available on your server. Please upgrade to Cosmos Pro to access this feature.", nil) + utils.HTTPError(w, "This feature is only available in Cosmos Pro", http.StatusForbidden, "PRO001") + return +} + +// createDeployment godoc +// @Summary Create a new cluster deployment +// @Description Creates a new deployment definition in the constellation-deployments KV (Pro feature) +// @Tags deployments +// @Accept json +// @Produce json +// @Security BearerAuth +// @Param body body Deployment true "Deployment definition" +// @Success 200 {object} utils.APIResponse +// @Failure 400 {object} utils.HTTPErrorResult +// @Failure 401 {object} utils.HTTPErrorResult +// @Failure 409 {object} utils.HTTPErrorResult +// @Router /api/constellation/deployments [post] +func createDeployment(w http.ResponseWriter, req *http.Request, lock *sync.RWMutex, js nats.JetStreamContext) { + utils.Error("This is a pro and is not currently available on your server. Please upgrade to Cosmos Pro to access this feature.", nil) + utils.HTTPError(w, "This feature is only available in Cosmos Pro", http.StatusForbidden, "PRO001") + return +} + +// getDeployment godoc +// @Summary Get a cluster deployment by name +// @Description Returns a single deployment definition (Pro feature) +// @Tags deployments +// @Produce json +// @Security BearerAuth +// @Param name path string true "Deployment name" +// @Success 200 {object} utils.APIResponse +// @Failure 401 {object} utils.HTTPErrorResult +// @Failure 404 {object} utils.HTTPErrorResult +// @Router /api/constellation/deployments/{name} [get] +func getDeployment(w http.ResponseWriter, req *http.Request, lock *sync.RWMutex, js nats.JetStreamContext) { + utils.Error("This is a pro and is not currently available on your server. Please upgrade to Cosmos Pro to access this feature.", nil) + utils.HTTPError(w, "This feature is only available in Cosmos Pro", http.StatusForbidden, "PRO001") + return +} + +// updateDeployment godoc +// @Summary Update a cluster deployment +// @Description Updates an existing deployment definition (Pro feature) +// @Tags deployments +// @Accept json +// @Produce json +// @Security BearerAuth +// @Param name path string true "Deployment name" +// @Param body body Deployment true "Updated deployment" +// @Success 200 {object} utils.APIResponse +// @Failure 400 {object} utils.HTTPErrorResult +// @Failure 401 {object} utils.HTTPErrorResult +// @Failure 404 {object} utils.HTTPErrorResult +// @Router /api/constellation/deployments/{name} [put] +func updateDeployment(w http.ResponseWriter, req *http.Request, lock *sync.RWMutex, js nats.JetStreamContext) { + utils.Error("This is a pro and is not currently available on your server. Please upgrade to Cosmos Pro to access this feature.", nil) + utils.HTTPError(w, "This feature is only available in Cosmos Pro", http.StatusForbidden, "PRO001") + return +} + +// deleteDeployment godoc +// @Summary Delete a cluster deployment +// @Description Removes a deployment from the constellation-deployments KV (Pro feature) +// @Tags deployments +// @Produce json +// @Security BearerAuth +// @Param name path string true "Deployment name" +// @Success 200 {object} utils.APIResponse +// @Failure 401 {object} utils.HTTPErrorResult +// @Failure 404 {object} utils.HTTPErrorResult +// @Router /api/constellation/deployments/{name} [delete] +func deleteDeployment(w http.ResponseWriter, req *http.Request, lock *sync.RWMutex, js nats.JetStreamContext) { + utils.Error("This is a pro and is not currently available on your server. Please upgrade to Cosmos Pro to access this feature.", nil) + utils.HTTPError(w, "This feature is only available in Cosmos Pro", http.StatusForbidden, "PRO001") + return +}