Bump react-day-picker from 9.14.0 to 10.0.1

Bumps [react-day-picker](https://github.com/gpbl/react-day-picker/tree/HEAD/packages/react-day-picker) from 9.14.0 to 10.0.1.
- [Release notes](https://github.com/gpbl/react-day-picker/releases)
- [Changelog](https://github.com/gpbl/react-day-picker/blob/main/packages/react-day-picker/CHANGELOG.md)
- [Commits](https://github.com/gpbl/react-day-picker/commits/v10.0.1/packages/react-day-picker)

---
updated-dependencies:
- dependency-name: react-day-picker
  dependency-version: 10.0.1
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

install/config/config.yml

@@ -37,8 +37,3 @@ flags:
     disable_signup_without_invite: true
     disable_user_create_org: false
     allow_raw_resources: true
-
-{{if .IsPostgreSQL}}
-postgres:
-  connection_string: postgresql://pangolin:{{.IsPostgreSQLPass}}@postgres:5432/pangolin
-{{end}}

install/config/docker-compose.yml

@@ -1,7 +1,7 @@
 name: pangolin
 services:
   pangolin:
-    image: docker.io/fosrl/pangolin:{{if .IsEnterprise}}ee-{{end}}{{if .IsPostgreSQL}}postgresql-{{end}}{{.PangolinVersion}}
+    image: docker.io/fosrl/pangolin:{{if .IsEnterprise}}ee-{{end}}{{.PangolinVersion}}
     container_name: pangolin
     restart: unless-stopped
     deploy:
@@ -10,20 +10,6 @@ services:
           memory: 1g
         reservations:
           memory: 256m
-{{if or .IsPostgreSQL .IsRedis}}
-    depends_on:
-    {{if .IsPostgreSQL}}
-      postgres:
-        condition: service_healthy
-    {{end}}
-    {{if .IsRedis}}
-      redis:
-        condition: service_healthy
-    {{end}}
-    networks:
-      - default
-      - backend
-{{end}}
     volumes:
       - ./config:/app/config
     healthcheck:
@@ -74,56 +60,8 @@ services:
       - ./config/letsencrypt:/letsencrypt # Volume to store the Let's Encrypt certificates
       - ./config/traefik/logs:/var/log/traefik # Volume to store Traefik logs
 
-{{if .IsPostgreSQL}}
-  postgres:
-    image: postgres:18
-    container_name: postgres
-    restart: unless-stopped
-    environment:
-      POSTGRES_USER: pangolin
-      POSTGRES_PASSWORD: {{.IsPostgreSQLPass}}
-      POSTGRES_DB: pangolin
-    volumes:
-      - ./postgres18:/var/lib/postgresql
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U pangolin"]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-    networks:
-      - backend
-{{end}}
-
-{{if .IsRedis}}
-  redis:
-    image: redis:8-trixie
-    container_name: redis
-    restart: unless-stopped
-    command: >
-      redis-server
-      --save 3600 1000
-      --appendonly yes
-      --requirepass {{.IsRedisPass}}
-    volumes:
-      - ./redis8:/data
-    healthcheck:
-      test: ["CMD", "redis-cli", "-a", "{{.IsRedisPass}}", "ping"]
-      interval: 10s
-      timeout: 3s
-      retries: 3
-      start_period: 10s
-    networks:
-      - backend
-{{end}}
-
 networks:
   default:
     driver: bridge
-    name: pangolin_frontend
+    name: pangolin
 {{if .EnableIPv6}}    enable_ipv6: true{{end}}
-{{if or .IsPostgreSQL .IsRedis}}
-  backend:
-    driver: bridge
-    name: pangolin_backend
-    internal: true
-{{end}}

install/config/privateConfig.yml

@@ -1,6 +0,0 @@
-{{if .IsRedis}}
-redis:
-  host: "redis"
-  port: 6379
-  password: "{{.IsRedisPass}}"
-{{end}}

install/main.go

@@ -57,10 +57,6 @@ type Config struct {
 	EnableMaxMind             bool
 	Secret                    string
 	IsEnterprise              bool
-    IsPostgreSQL              bool
-	IsPostgreSQLPass          string
-    IsRedis                   bool
-	IsRedisPass               string
 }
 
 type SupportedContainer string
@@ -490,17 +486,6 @@ func collectUserInput() Config {
 	fmt.Println("\n=== Basic Configuration ===")
 
 	config.IsEnterprise = readBoolNoDefault("Do you want to install the Enterprise version of Pangolin? The EE is free for personal use or for businesses making less than 100k USD annually.")
-    if config.IsEnterprise {
-        config.IsRedis = readBool("Do you want to run the Redis containers locally? Required for HA.")
-        if config.IsRedis {
-            config.IsRedisPass = readPassword("Enter a unique password for the Redis service.")
-        }
-    }
-
-    config.IsPostgreSQL = readBool("Do you want to run the PostgreSQL containers locally? Otherwise, default to the local SQLite database only.", false)
-	if config.IsPostgreSQL {
-		config.IsPostgreSQLPass = readPassword("Enter a unique password for the PostgreSQL pangolin user.")
-	}
 
 	config.BaseDomain = readString("Enter your base domain (no subdomain e.g. example.com)", "")
 

package-lock.json

@@ -81,7 +81,7 @@
                 "posthog-node": "5.35.6",
                 "qrcode.react": "4.2.0",
                 "react": "19.2.6",
-                "react-day-picker": "9.14.0",
+                "react-day-picker": "10.0.1",
                 "react-dom": "19.2.6",
                 "react-easy-sort": "1.8.0",
                 "react-hook-form": "7.76.1",
@@ -6963,15 +6963,6 @@
                 "@swc/counter": "^0.1.3"
             }
         },
-        "node_modules/@tabby_ai/hijri-converter": {
-            "version": "1.0.5",
-            "resolved": "https://registry.npmjs.org/@tabby_ai/hijri-converter/-/hijri-converter-1.0.5.tgz",
-            "integrity": "sha512-r5bClKrcIusDoo049dSL8CawnHR6mRdDwhlQuIgZRNty68q0x8k3Lf1BtPAMxRf/GgnHBnIO4ujd3+GQdLWzxQ==",
-            "license": "MIT",
-            "engines": {
-                "node": ">=16.0.0"
-            }
-        },
         "node_modules/@tailwindcss/forms": {
             "version": "0.5.11",
             "resolved": "https://registry.npmjs.org/@tailwindcss/forms/-/forms-0.5.11.tgz",
@@ -10284,12 +10275,6 @@
                 "url": "https://github.com/sponsors/kossnocorp"
             }
         },
-        "node_modules/date-fns-jalali": {
-            "version": "4.1.0-0",
-            "resolved": "https://registry.npmjs.org/date-fns-jalali/-/date-fns-jalali-4.1.0-0.tgz",
-            "integrity": "sha512-hTIP/z+t+qKwBDcmmsnmjWTduxCg+5KfdqWQvb2X/8C9+knYY6epN/pfxdDuyVlSVeFz0sM5eEfwIUQ70U4ckg==",
-            "license": "MIT"
-        },
         "node_modules/debounce": {
             "version": "2.2.0",
             "resolved": "https://registry.npmjs.org/debounce/-/debounce-2.2.0.tgz",
@@ -15765,15 +15750,13 @@
             }
         },
         "node_modules/react-day-picker": {
-            "version": "9.14.0",
+            "version": "10.0.1",
-            "resolved": "https://registry.npmjs.org/react-day-picker/-/react-day-picker-9.14.0.tgz",
+            "resolved": "https://registry.npmjs.org/react-day-picker/-/react-day-picker-10.0.1.tgz",
-            "integrity": "sha512-tBaoDWjPwe0M5pGrum4H0SR6Lyk+BO9oHnp9JbKpGKW2mlraNPgP9BMfsg5pWpwrssARmeqk7YBl2oXutZTaHA==",
+            "integrity": "sha512-eNh6BlwcYInWaJtRv18mXQ06Ys/H6rdTZAnTaSdOYJuTpwP1JMCHNd1FDRadA+gbeinq+psdULN5Xnowy9mV8w==",
             "license": "MIT",
             "dependencies": {
                 "@date-fns/tz": "^1.4.1",
-                "@tabby_ai/hijri-converter": "1.0.5",
+                "date-fns": "^4.1.0"
-                "date-fns": "^4.1.0",
-                "date-fns-jalali": "4.1.0-0"
             },
             "engines": {
                 "node": ">=18"
@@ -15783,7 +15766,13 @@
                 "url": "https://github.com/sponsors/gpbl"
             },
             "peerDependencies": {
+                "@types/react": ">=16.8.0",
                 "react": ">=16.8.0"
+            },
+            "peerDependenciesMeta": {
+                "@types/react": {
+                    "optional": true
+                }
             }
         },
         "node_modules/react-dom": {

package.json

@@ -104,7 +104,7 @@
         "posthog-node": "5.35.6",
         "qrcode.react": "4.2.0",
         "react": "19.2.6",
-        "react-day-picker": "9.14.0",
+        "react-day-picker": "10.0.1",
         "react-dom": "19.2.6",
         "react-easy-sort": "1.8.0",
         "react-hook-form": "7.76.1",

server/integrationApiServer.ts

@@ -152,17 +152,11 @@ function getOpenApiDocumentation() {
 
             if (!hasExistingResponses) {
                 def.route.responses = {
-                    "200": {
+                    "*": {
-                        description: "Successful response",
+                        description: "",
                         content: {
                             "application/json": {
-                                schema: z.object({
+                                schema: z.object({})
-                                    data: z.unknown().nullable(),
-                                    success: z.boolean(),
-                                    error: z.boolean(),
-                                    message: z.string(),
-                                    status: z.number()
-                                })
                             }
                         }
                     }

server/lib/ip.ts

@@ -873,13 +873,7 @@ export const portRangeStringSchema = z
             message:
                 'Port range must be "*" for all ports, or a comma-separated list of ports and ranges (e.g., "80,443,8000-9000"). Ports must be between 1 and 65535, and ranges must have start <= end.'
         }
-    )
+    );
-    .openapi({
-        type: "string",
-        description:
-            'Port range string. Use "*" for all ports, a comma-separated list of ports, or ranges (e.g., "80,443,8000-9000"). Ports must be between 1 and 65535.',
-        example: "80,443,8000-9000"
-    });
 
 /**
  * Parses a port range string into an array of port range objects

server/lib/openapi/createApiResponseSchema.ts

@@ -1,11 +0,0 @@
-import { z } from "zod";
-
-export function createApiResponseSchema<T extends z.ZodTypeAny>(dataSchema: T) {
-    return z.object({
-        data: dataSchema.nullable(),
-        success: z.boolean(),
-        error: z.boolean(),
-        message: z.string(),
-        status: z.number()
-    });
-}

server/private/routers/alertRule/createAlertRule.ts

@@ -202,22 +202,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function createAlertRule(

server/private/routers/alertRule/deleteAlertRule.ts

@@ -38,22 +38,7 @@ registry.registerPath({
     request: {
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function deleteAlertRule(

server/private/routers/alertRule/getAlertRule.ts

@@ -49,22 +49,7 @@ registry.registerPath({
     request: {
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function getAlertRule(

server/private/routers/alertRule/listAlertRules.ts

@@ -95,22 +95,7 @@ registry.registerPath({
         query: querySchema,
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function listAlertRules(

server/private/routers/alertRule/updateAlertRule.ts

@@ -13,7 +13,6 @@
 
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { db } from "@server/db";
 import {
     alertRules,
@@ -149,10 +148,6 @@ const bodySchema = z
 export type UpdateAlertRuleResponse = {
     alertRuleId: number;
 };
-const UpdateAlertRuleResponseDataSchema = z.object({
-    alertRuleId: z.number()
-});
-
 
 registry.registerPath({
     method: "post",
@@ -169,16 +164,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(UpdateAlertRuleResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function updateAlertRule(

server/private/routers/approvals/processPendingApproval.ts

@@ -24,7 +24,7 @@ import type { NextFunction, Request, Response } from "express";
 
 const paramsSchema = z.strictObject({
     orgId: z.string(),
-    approvalId: z.coerce.number().int().positive()
+    approvalId: z.string().transform(Number).pipe(z.int().positive())
 });
 
 const bodySchema = z.strictObject({

server/private/routers/auditLogs/exportAccessAuditLog.ts

@@ -18,7 +18,6 @@ import { OpenAPITags } from "@server/openApi";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
 import { fromError } from "zod-validation-error";
-import { z } from "zod";
 import logger from "@server/logger";
 import {
     queryAccessAuditLogsParams,
@@ -38,22 +37,7 @@ registry.registerPath({
         query: queryAccessAuditLogsQuery,
         params: queryAccessAuditLogsParams
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function exportAccessAuditLogs(

server/private/routers/auditLogs/exportActionAuditLog.ts

@@ -18,7 +18,6 @@ import { OpenAPITags } from "@server/openApi";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
 import { fromError } from "zod-validation-error";
-import { z } from "zod";
 import logger from "@server/logger";
 import {
     queryActionAuditLogsParams,
@@ -38,22 +37,7 @@ registry.registerPath({
         query: queryActionAuditLogsQuery,
         params: queryActionAuditLogsParams
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function exportActionAuditLogs(

server/private/routers/auditLogs/exportConnectionAuditLog.ts

@@ -18,7 +18,6 @@ import { OpenAPITags } from "@server/openApi";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
 import { fromError } from "zod-validation-error";
-import { z } from "zod";
 import logger from "@server/logger";
 import {
     queryConnectionAuditLogsParams,
@@ -38,22 +37,7 @@ registry.registerPath({
         query: queryConnectionAuditLogsQuery,
         params: queryConnectionAuditLogsParams
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function exportConnectionAuditLogs(

server/private/routers/auditLogs/queryAccessAuditLog.ts

@@ -338,22 +338,7 @@ registry.registerPath({
         query: queryAccessAuditLogsQuery,
         params: queryAccessAuditLogsParams
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function queryAccessAuditLogs(

server/private/routers/auditLogs/queryActionAuditLog.ts

@@ -165,22 +165,7 @@ registry.registerPath({
         query: queryActionAuditLogsQuery,
         params: queryActionAuditLogsParams
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function queryActionAuditLogs(

server/private/routers/auditLogs/queryConnectionAuditLog.ts

@@ -453,22 +453,7 @@ registry.registerPath({
         query: queryConnectionAuditLogsQuery,
         params: queryConnectionAuditLogsParams
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function queryConnectionAuditLogs(

server/private/routers/billing/getOrgUsage.ts

@@ -39,22 +39,7 @@ const getOrgSchema = z.strictObject({
 //     request: {
 //         params: getOrgSchema
 //     },
-// responses: {
+//     responses: {}
-// 200: {
-// description: "Successful response",
-// content: {
-// "application/json": {
-// schema: z.object({
-// data: z.unknown().nullable(),
-// success: z.boolean(),
-// error: z.boolean(),
-// message: z.string(),
-// status: z.number()
-// })
-// }
-// }
-// }
-// }
 // });
 
 export async function getOrgUsage(

server/private/routers/certificates/getCertificate.ts

@@ -115,22 +115,7 @@ registry.registerPath({
             orgId: z.string()
         })
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function getCertificate(

server/private/routers/certificates/restartCertificate.ts

@@ -25,7 +25,7 @@ import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 
 const restartCertificateParamsSchema = z.strictObject({
-    certId: z.coerce.number().int().positive(),
+    certId: z.string().transform(stoi).pipe(z.int().positive()),
     orgId: z.string()
 });
 
@@ -36,26 +36,11 @@ registry.registerPath({
     tags: ["Certificate"],
     request: {
         params: z.object({
-            certId: z.coerce.number().int().positive(),
+            certId: z.string().transform(stoi).pipe(z.int().positive()),
             orgId: z.string()
         })
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function restartCertificate(

server/private/routers/domain/checkDomainNamespaceAvailability.ts

@@ -42,22 +42,7 @@ registry.registerPath({
         params: paramsSchema,
         query: querySchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function checkDomainNamespaceAvailability(

server/private/routers/domain/listDomainNamespaces.ts

@@ -25,7 +25,6 @@ import { OpenAPITags, registry } from "@server/openApi";
 import { isSubscribed } from "#private/lib/isSubscribed";
 import { build } from "@server/build";
 import { tierMatrix } from "@server/lib/billing/tierMatrix";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 
 const paramsSchema = z.strictObject({});
 
@@ -66,20 +65,6 @@ export type ListDomainNamespacesResponse = {
     pagination: { total: number; limit: number; offset: number };
 };
 
-const ListDomainNamespacesResponseDataSchema = z.object({
-    domainNamespaces: z.array(
-        z.object({
-            domainNamespaceId: z.string(),
-            domainId: z.string()
-        })
-    ),
-    pagination: z.object({
-        total: z.number(),
-        limit: z.number(),
-        offset: z.number()
-    })
-});
-
 registry.registerPath({
     method: "get",
     path: "/domains/namepaces",
@@ -88,18 +73,7 @@ registry.registerPath({
     request: {
         query: querySchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(
-                        ListDomainNamespacesResponseDataSchema
-                    )
-                }
-            }
-        }
-    }
 });
 
 export async function listDomainNamespaces(

server/private/routers/eventStreamingDestination/createEventStreamingDestination.ts

@@ -13,7 +13,6 @@
 
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { db } from "@server/db";
 import { eventStreamingDestinations } from "@server/db";
 import { logStreamingManager } from "#private/lib/logStreaming";
@@ -43,10 +42,6 @@ const bodySchema = z.strictObject({
 export type CreateEventStreamingDestinationResponse = {
     destinationId: number;
 };
-const CreateEventStreamingDestinationResponseDataSchema = z.object({
-    destinationId: z.number()
-});
-
 
 registry.registerPath({
     method: "put",
@@ -63,16 +58,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(CreateEventStreamingDestinationResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function createEventStreamingDestination(

server/private/routers/eventStreamingDestination/deleteEventStreamingDestination.ts

@@ -38,22 +38,7 @@ registry.registerPath({
     request: {
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function deleteEventStreamingDestination(

server/private/routers/eventStreamingDestination/listEventStreamingDestinations.ts

@@ -24,7 +24,6 @@ import { OpenAPITags, registry } from "@server/openApi";
 import { eq, sql } from "drizzle-orm";
 import { decrypt } from "@server/lib/crypto";
 import config from "@server/lib/config";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 
 const paramsSchema = z.strictObject({
     orgId: z.string().nonempty()
@@ -68,31 +67,6 @@ export type ListEventStreamingDestinationsResponse = {
     };
 };
 
-const ListEventStreamingDestinationsResponseDataSchema = z.object({
-    destinations: z.array(
-        z.object({
-            destinationId: z.number(),
-            orgId: z.string(),
-            type: z.string(),
-            config: z.string(),
-            enabled: z.boolean(),
-            lastError: z.string().nullable(),
-            lastErrorAt: z.number().nullable(),
-            createdAt: z.number(),
-            updatedAt: z.number(),
-            sendConnectionLogs: z.boolean(),
-            sendRequestLogs: z.boolean(),
-            sendActionLogs: z.boolean(),
-            sendAccessLogs: z.boolean()
-        })
-    ),
-    pagination: z.object({
-        total: z.number(),
-        limit: z.number(),
-        offset: z.number()
-    })
-});
-
 async function query(orgId: string, limit: number, offset: number) {
     const res = await db
         .select()
@@ -114,18 +88,7 @@ registry.registerPath({
         query: querySchema,
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(
-                        ListEventStreamingDestinationsResponseDataSchema
-                    )
-                }
-            }
-        }
-    }
 });
 
 export async function listEventStreamingDestinations(

server/private/routers/eventStreamingDestination/updateEventStreamingDestination.ts

@@ -13,7 +13,6 @@
 
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { db } from "@server/db";
 import { eventStreamingDestinations } from "@server/db";
 import response from "@server/lib/response";
@@ -46,10 +45,6 @@ const bodySchema = z.strictObject({
 export type UpdateEventStreamingDestinationResponse = {
     destinationId: number;
 };
-const UpdateEventStreamingDestinationResponseDataSchema = z.object({
-    destinationId: z.number()
-});
-
 
 registry.registerPath({
     method: "post",
@@ -66,16 +61,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(UpdateEventStreamingDestinationResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function updateEventStreamingDestination(

server/private/routers/healthChecks/createHealthCheck.ts

@@ -13,7 +13,6 @@
 
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { db, targetHealthCheck, newts, sites } from "@server/db";
 import { eq } from "drizzle-orm";
 import response from "@server/lib/response";
@@ -53,10 +52,6 @@ const bodySchema = z.strictObject({
 export type CreateHealthCheckResponse = {
     targetHealthCheckId: number;
 };
-const CreateHealthCheckResponseDataSchema = z.object({
-    targetHealthCheckId: z.number()
-});
-
 
 registry.registerPath({
     method: "put",
@@ -73,16 +68,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(CreateHealthCheckResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function createHealthCheck(

server/private/routers/healthChecks/deleteHealthCheck.ts

@@ -41,22 +41,7 @@ registry.registerPath({
     request: {
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function deleteHealthCheck(

server/private/routers/healthChecks/listHealthChecks.ts

@@ -68,22 +68,7 @@ registry.registerPath({
         params: paramsSchema,
         query: querySchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function listHealthChecks(

server/private/routers/healthChecks/updateHealthCheck.ts

@@ -13,7 +13,6 @@
 
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { db, targetHealthCheck, newts, sites } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
@@ -82,29 +81,6 @@ export type UpdateHealthCheckResponse = {
     hcHealthyThreshold: number | null;
     hcUnhealthyThreshold: number | null;
 };
-const UpdateHealthCheckResponseDataSchema = z.object({
-    targetHealthCheckId: z.number(),
-    name: z.string().nullable(),
-    siteId: z.number().nullable(),
-    hcEnabled: z.boolean(),
-    hcHealth: z.string().nullable(),
-    hcMode: z.string().nullable(),
-    hcHostname: z.string().nullable(),
-    hcPort: z.number().nullable(),
-    hcPath: z.string().nullable(),
-    hcScheme: z.string().nullable(),
-    hcMethod: z.string().nullable(),
-    hcInterval: z.number().nullable(),
-    hcUnhealthyInterval: z.number().nullable(),
-    hcTimeout: z.number().nullable(),
-    hcHeaders: z.string().nullable(),
-    hcFollowRedirects: z.boolean().nullable(),
-    hcStatus: z.number().nullable(),
-    hcTlsServerName: z.string().nullable(),
-    hcHealthyThreshold: z.number().nullable(),
-    hcUnhealthyThreshold: z.number().nullable()
-});
-
 
 registry.registerPath({
     method: "post",
@@ -121,16 +97,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(UpdateHealthCheckResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function updateHealthCheck(

server/private/routers/orgIdp/createOrgOidcIdp.ts

@@ -63,22 +63,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function createOrgOidcIdp(

server/private/routers/orgIdp/deleteOrgIdp.ts

@@ -38,22 +38,7 @@ registry.registerPath({
     request: {
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function deleteOrgIdp(

server/private/routers/orgIdp/getOrgIdp.ts

@@ -56,22 +56,7 @@ registry.registerPath({
     request: {
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function getOrgIdp(

server/private/routers/orgIdp/listOrgIdps.ts

@@ -72,22 +72,7 @@ registry.registerPath({
         query: querySchema,
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function listOrgIdps(

server/private/routers/orgIdp/updateOrgOidcIdp.ts

@@ -13,7 +13,6 @@
 
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { db, idpOrg } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
@@ -55,10 +54,6 @@ const bodySchema = z.strictObject({
 export type UpdateOrgIdpResponse = {
     idpId: number;
 };
-const UpdateOrgIdpResponseDataSchema = z.object({
-    idpId: z.number()
-});
-
 
 registry.registerPath({
     method: "post",
@@ -75,16 +70,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(UpdateOrgIdpResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function updateOrgOidcIdp(

server/private/routers/re-key/reGenerateClientSecret.ts

@@ -28,7 +28,7 @@ import { OlmErrorCodes, sendOlmError } from "@server/routers/olm/error";
 import { sendTerminateClient } from "@server/routers/client/terminate";
 
 const reGenerateSecretParamsSchema = z.strictObject({
-    clientId: z.coerce.number().int().positive()
+    clientId: z.string().transform(Number).pipe(z.int().positive())
 });
 
 const reGenerateSecretBodySchema = z.strictObject({

server/private/routers/re-key/reGenerateSiteSecret.ts

@@ -27,7 +27,7 @@ import { getAllowedIps } from "@server/routers/target/helpers";
 import { disconnectClient, sendToClient } from "#private/routers/ws";
 
 const updateSiteParamsSchema = z.strictObject({
-    siteId: z.coerce.number().int().positive()
+    siteId: z.string().transform(Number).pipe(z.int().positive())
 });
 
 const updateSiteBodySchema = z.strictObject({

server/private/routers/ssh/signSshKey.ts

@@ -93,22 +93,7 @@ export type SignSshKeyResponse = {
 //             }
 //         }
 //     },
-// responses: {
+//     responses: {}
-// 200: {
-// description: "Successful response",
-// content: {
-// "application/json": {
-// schema: z.object({
-// data: z.unknown().nullable(),
-// success: z.boolean(),
-// error: z.boolean(),
-// message: z.string(),
-// status: z.number()
-// })
-// }
-// }
-// }
-// }
 // });
 
 export async function signSshKey(

server/private/routers/user/addUserRole.ts

@@ -27,7 +27,7 @@ import { rebuildClientAssociationsFromClient } from "@server/lib/rebuildClientAs
 
 const addUserRoleParamsSchema = z.strictObject({
     userId: z.string(),
-    roleId: z.coerce.number()
+    roleId: z.string().transform(stoi).pipe(z.number())
 });
 
 registry.registerPath({
@@ -38,22 +38,7 @@ registry.registerPath({
     request: {
         params: addUserRoleParamsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function addUserRole(

server/private/routers/user/removeUserRole.ts

@@ -27,7 +27,7 @@ import { rebuildClientAssociationsFromClient } from "@server/lib/rebuildClientAs
 
 const removeUserRoleParamsSchema = z.strictObject({
     userId: z.string(),
-    roleId: z.coerce.number()
+    roleId: z.string().transform(stoi).pipe(z.number())
 });
 
 registry.registerPath({
@@ -39,22 +39,7 @@ registry.registerPath({
     request: {
         params: removeUserRoleParamsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function removeUserRole(

server/routers/accessToken/deleteAccessToken.ts

@@ -22,22 +22,7 @@ registry.registerPath({
     request: {
         params: deleteAccessTokenParamsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function deleteAccessToken(

server/routers/accessToken/generateAccessToken.ts

@@ -31,7 +31,7 @@ export const generateAccessTokenBodySchema = z.strictObject({
 });
 
 export const generateAccssTokenParamsSchema = z.strictObject({
-    resourceId: z.coerce.number().int().positive()
+    resourceId: z.string().transform(Number).pipe(z.int().positive())
 });
 
 export type GenerateAccessTokenResponse = Omit<
@@ -54,22 +54,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function generateAccessToken(

server/routers/accessToken/listAccessTokens.ts

@@ -129,22 +129,7 @@ registry.registerPath({
         }),
         query: listAccessTokensSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 registry.registerPath({
@@ -158,22 +143,7 @@ registry.registerPath({
         }),
         query: listAccessTokensSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function listAccessTokens(

server/routers/apiKeys/createOrgApiKey.ts

@@ -2,7 +2,6 @@ import { NextFunction, Request, Response } from "express";
 import { db } from "@server/db";
 import HttpCode from "@server/types/HttpCode";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { apiKeyOrg, apiKeys } from "@server/db";
 import { fromError } from "zod-validation-error";
 import createHttpError from "http-errors";
@@ -33,14 +32,6 @@ export type CreateOrgApiKeyResponse = {
     lastChars: string;
     createdAt: string;
 };
-const CreateOrgApiKeyResponseDataSchema = z.object({
-    apiKeyId: z.string(),
-    name: z.string(),
-    apiKey: z.string(),
-    lastChars: z.string(),
-    createdAt: z.string()
-});
-
 
 registry.registerPath({
     method: "put",
@@ -57,16 +48,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(CreateOrgApiKeyResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function createOrgApiKey(

server/routers/apiKeys/deleteApiKey.ts

@@ -22,22 +22,7 @@ registry.registerPath({
     request: {
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function deleteApiKey(

server/routers/apiKeys/listApiKeyActions.ts

@@ -9,7 +9,6 @@ import { z } from "zod";
 import { fromError } from "zod-validation-error";
 import { eq } from "drizzle-orm";
 import { OpenAPITags, registry } from "@server/openApi";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 
 const paramsSchema = z.object({
     apiKeyId: z.string().nonempty()
@@ -45,19 +44,6 @@ export type ListApiKeyActionsResponse = {
     pagination: { total: number; limit: number; offset: number };
 };
 
-const ListApiKeyActionsResponseDataSchema = z.object({
-    actions: z.array(
-        z.object({
-            actionId: z.string()
-        })
-    ),
-    pagination: z.object({
-        total: z.number(),
-        limit: z.number(),
-        offset: z.number()
-    })
-});
-
 registry.registerPath({
     method: "get",
     path: "/org/{orgId}/api-key/{apiKeyId}/actions",
@@ -67,18 +53,7 @@ registry.registerPath({
         params: paramsSchema,
         query: querySchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(
-                        ListApiKeyActionsResponseDataSchema
-                    )
-                }
-            }
-        }
-    }
 });
 
 export async function listApiKeyActions(

server/routers/apiKeys/listOrgApiKeys.ts

@@ -9,7 +9,6 @@ import { z } from "zod";
 import { fromError } from "zod-validation-error";
 import { eq, and } from "drizzle-orm";
 import { OpenAPITags, registry } from "@server/openApi";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 
 const querySchema = z.object({
     limit: z
@@ -49,23 +48,6 @@ export type ListOrgApiKeysResponse = {
     pagination: { total: number; limit: number; offset: number };
 };
 
-const ListOrgApiKeysResponseDataSchema = z.object({
-    apiKeys: z.array(
-        z.object({
-            apiKeyId: z.string(),
-            orgId: z.string(),
-            lastChars: z.string(),
-            createdAt: z.string(),
-            name: z.string()
-        })
-    ),
-    pagination: z.object({
-        total: z.number(),
-        limit: z.number(),
-        offset: z.number()
-    })
-});
-
 registry.registerPath({
     method: "get",
     path: "/org/{orgId}/api-keys",
@@ -75,18 +57,7 @@ registry.registerPath({
         params: paramsSchema,
         query: querySchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(
-                        ListOrgApiKeysResponseDataSchema
-                    )
-                }
-            }
-        }
-    }
 });
 
 export async function listOrgApiKeys(

server/routers/apiKeys/setApiKeyActions.ts

@@ -36,22 +36,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function setApiKeyActions(

server/routers/auditLogs/exportRequestAuditLog.ts

@@ -5,7 +5,6 @@ import { OpenAPITags } from "@server/openApi";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
 import { fromError } from "zod-validation-error";
-import { z } from "zod";
 import logger from "@server/logger";
 import {
     queryAccessAuditLogsQuery,
@@ -29,22 +28,7 @@ registry.registerPath({
         }),
         params: queryRequestAuditLogsParams
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function exportRequestAuditLogs(

server/routers/auditLogs/queryRequestAnalytics.ts

@@ -156,22 +156,7 @@ registry.registerPath({
         query: queryAccessAuditLogsQuery,
         params: queryRequestAuditLogsParams
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export type QueryRequestAnalyticsResponse = Awaited<ReturnType<typeof query>>;

server/routers/auditLogs/queryRequestAuditLog.ts

@@ -241,22 +241,7 @@ registry.registerPath({
         query: queryAccessAuditLogsQuery,
         params: queryRequestAuditLogsParams
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 async function queryUniqueFilterAttributes(

server/routers/auth/checkResourceSession.ts

@@ -9,7 +9,7 @@ import logger from "@server/logger";
 
 export const params = z.strictObject({
     token: z.string(),
-    resourceId: z.coerce.number().int().positive()
+    resourceId: z.string().transform(Number).pipe(z.int().positive())
 });
 
 export type CheckResourceSessionParams = z.infer<typeof params>;

server/routers/auth/lookupUser.ts

@@ -51,22 +51,7 @@ export type LookupUserResponse = {
 //     request: {
 //         body: lookupBodySchema
 //     },
-// responses: {
+//     responses: {}
-// 200: {
-// description: "Successful response",
-// content: {
-// "application/json": {
-// schema: z.object({
-// data: z.unknown().nullable(),
-// success: z.boolean(),
-// error: z.boolean(),
-// message: z.string(),
-// status: z.number()
-// })
-// }
-// }
-// }
-// }
 // });
 
 export async function lookupUser(

server/routers/blueprints/applyJSONBlueprint.ts

@@ -31,22 +31,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function applyJSONBlueprint(

server/routers/blueprints/applyYAMLBlueprint.ts

@@ -54,22 +54,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function applyYAMLBlueprint(

server/routers/blueprints/getBlueprint.ts

@@ -7,12 +7,13 @@ import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
+import stoi from "@server/lib/stoi";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 import { BlueprintData } from "./types";
 
 const getBlueprintSchema = z.strictObject({
-    blueprintId: z.coerce.number().int().positive(),
+    blueprintId: z.string().transform(stoi).pipe(z.int().positive()),
     orgId: z.string()
 });
 
@@ -56,22 +57,7 @@ registry.registerPath({
     request: {
         params: getBlueprintSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function getBlueprint(

server/routers/blueprints/listBlueprints.ts

@@ -74,22 +74,7 @@ registry.registerPath({
         }),
         query: listBluePrintsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function listBlueprints(

server/routers/client/archiveClient.ts

@@ -11,7 +11,7 @@ import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 
 const archiveClientSchema = z.strictObject({
-    clientId: z.coerce.number().int().positive()
+    clientId: z.string().transform(Number).pipe(z.int().positive())
 });
 
 registry.registerPath({
@@ -22,22 +22,7 @@ registry.registerPath({
     request: {
         params: archiveClientSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function archiveClient(

server/routers/client/blockClient.ts

@@ -13,7 +13,7 @@ import { sendTerminateClient } from "./terminate";
 import { OlmErrorCodes } from "../olm/error";
 
 const blockClientSchema = z.strictObject({
-    clientId: z.coerce.number().int().positive()
+    clientId: z.string().transform(Number).pipe(z.int().positive())
 });
 
 registry.registerPath({
@@ -24,22 +24,7 @@ registry.registerPath({
     request: {
         params: blockClientSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function blockClient(

server/routers/client/createClient.ts

@@ -59,22 +59,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function createClient(

server/routers/client/createUserClient.ts

@@ -60,22 +60,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function createUserClient(

server/routers/client/deleteClient.ts

@@ -14,7 +14,7 @@ import { sendTerminateClient } from "./terminate";
 import { OlmErrorCodes } from "../olm/error";
 
 const deleteClientSchema = z.strictObject({
-    clientId: z.coerce.number().int().positive()
+    clientId: z.string().transform(Number).pipe(z.int().positive())
 });
 
 registry.registerPath({
@@ -25,22 +25,7 @@ registry.registerPath({
     request: {
         params: deleteClientSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function deleteClient(

server/routers/client/getClient.ts

@@ -253,22 +253,7 @@ registry.registerPath({
             niceId: z.string()
         })
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 registry.registerPath({
@@ -281,22 +266,7 @@ registry.registerPath({
             clientId: z.number()
         })
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function getClient(

server/routers/client/listClients.ts

@@ -186,22 +186,7 @@ registry.registerPath({
         query: listClientsSchema,
         params: listClientsParamsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function listClients(

server/routers/client/listUserDevices.ts

@@ -213,22 +213,7 @@ registry.registerPath({
         query: listUserDevicesSchema,
         params: listUserDevicesParamsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function listUserDevices(

server/routers/client/pickClientDefaults.ts

@@ -6,7 +6,6 @@ import logger from "@server/logger";
 import { generateId } from "@server/auth/sessions/app";
 import { getNextAvailableClientSubnet } from "@server/lib/ip";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 
@@ -15,12 +14,6 @@ export type PickClientDefaultsResponse = {
     olmSecret: string;
     subnet: string;
 };
-const PickClientDefaultsResponseDataSchema = z.object({
-    olmId: z.string(),
-    olmSecret: z.string(),
-    subnet: z.string()
-});
-
 
 const pickClientDefaultsSchema = z.strictObject({
     orgId: z.string()
@@ -34,16 +27,7 @@ registry.registerPath({
     request: {
         params: pickClientDefaultsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(PickClientDefaultsResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function pickClientDefaults(

server/routers/client/unarchiveClient.ts

@@ -11,7 +11,7 @@ import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 
 const unarchiveClientSchema = z.strictObject({
-    clientId: z.coerce.number().int().positive()
+    clientId: z.string().transform(Number).pipe(z.int().positive())
 });
 
 registry.registerPath({
@@ -22,22 +22,7 @@ registry.registerPath({
     request: {
         params: unarchiveClientSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function unarchiveClient(

server/routers/client/unblockClient.ts

@@ -11,7 +11,7 @@ import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 
 const unblockClientSchema = z.strictObject({
-    clientId: z.coerce.number().int().positive()
+    clientId: z.string().transform(Number).pipe(z.int().positive())
 });
 
 registry.registerPath({
@@ -22,22 +22,7 @@ registry.registerPath({
     request: {
         params: unblockClientSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function unblockClient(

server/routers/client/updateClient.ts

@@ -11,7 +11,7 @@ import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 
 const updateClientParamsSchema = z.strictObject({
-    clientId: z.coerce.number().int().positive()
+    clientId: z.string().transform(Number).pipe(z.int().positive())
 });
 
 const updateClientSchema = z.strictObject({
@@ -36,22 +36,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function updateClient(

server/routers/domain/getDNSRecords.ts

@@ -37,22 +37,7 @@ registry.registerPath({
             orgId: z.string()
         })
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function getDNSRecords(

server/routers/domain/getDomain.ts

@@ -38,22 +38,7 @@ registry.registerPath({
             orgId: z.string()
         })
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function getDomain(

server/routers/domain/listDomains.ts

@@ -9,7 +9,6 @@ import { eq, sql } from "drizzle-orm";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 
 const listDomainsParamsSchema = z.strictObject({
     orgId: z.string()
@@ -57,28 +56,6 @@ export type ListDomainsResponse = {
     pagination: { total: number; limit: number; offset: number };
 };
 
-const ListDomainsResponseDataSchema = z.object({
-    domains: z.array(
-        z.object({
-            domainId: z.string(),
-            baseDomain: z.string(),
-            verified: z.boolean(),
-            type: z.string().nullable(),
-            failed: z.boolean(),
-            tries: z.number(),
-            configManaged: z.boolean(),
-            certResolver: z.string().nullable(),
-            preferWildcardCert: z.boolean().nullable(),
-            errorMessage: z.string().nullable()
-        })
-    ),
-    pagination: z.object({
-        total: z.number(),
-        limit: z.number(),
-        offset: z.number()
-    })
-});
-
 registry.registerPath({
     method: "get",
     path: "/org/{orgId}/domains",
@@ -90,16 +67,7 @@ registry.registerPath({
         }),
         query: listDomainsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(ListDomainsResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function listDomains(

server/routers/domain/updateDomain.ts

@@ -1,6 +1,5 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { db, domains, orgDomains } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
@@ -25,12 +24,6 @@ export type UpdateDomainResponse = {
     certResolver: string | null;
     preferWildcardCert: boolean | null;
 };
-const UpdateDomainResponseDataSchema = z.object({
-    domainId: z.string(),
-    certResolver: z.string().nullable(),
-    preferWildcardCert: z.boolean().nullable()
-});
-
 
 registry.registerPath({
     method: "patch",
@@ -43,16 +36,7 @@ registry.registerPath({
             orgId: z.string()
         })
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(UpdateDomainResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function updateOrgDomain(

server/routers/idp/createIdpOrgPolicy.ts

@@ -1,6 +1,5 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { db } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
@@ -23,8 +22,6 @@ const bodySchema = z.strictObject({
 });
 
 export type CreateIdpOrgPolicyResponse = {};
-const CreateIdpOrgPolicyResponseDataSchema = z.object({});
-
 
 registry.registerPath({
     method: "put",
@@ -41,16 +38,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(CreateIdpOrgPolicyResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function createIdpOrgPolicy(

server/routers/idp/createOidcIdp.ts

@@ -1,6 +1,5 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { db } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
@@ -34,11 +33,6 @@ export type CreateIdpResponse = {
     idpId: number;
     redirectUrl: string;
 };
-const CreateIdpResponseDataSchema = z.object({
-    idpId: z.number(),
-    redirectUrl: z.string()
-});
-
 
 registry.registerPath({
     method: "put",
@@ -54,16 +48,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(CreateIdpResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function createOidcIdp(

server/routers/idp/deleteIdp.ts

@@ -25,22 +25,7 @@ registry.registerPath({
     request: {
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function deleteIdp(

server/routers/idp/deleteIdpOrgPolicy.ts

@@ -23,22 +23,7 @@ registry.registerPath({
     request: {
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function deleteIdpOrgPolicy(

server/routers/idp/getIdp.ts

@@ -38,22 +38,7 @@ registry.registerPath({
     request: {
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function getIdp(

server/routers/idp/listIdpOrgPolicies.ts

@@ -9,7 +9,6 @@ import { eq, sql } from "drizzle-orm";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 
 const paramsSchema = z.object({
     idpId: z.coerce.number<number>()
@@ -45,21 +44,6 @@ export type ListIdpOrgPoliciesResponse = {
     pagination: { total: number; limit: number; offset: number };
 };
 
-const ListIdpOrgPoliciesResponseDataSchema = z.object({
-    policies: z.array(
-        z.object({
-            idpId: z.number(),
-            orgId: z.string(),
-            assignDefaultOrgRoleId: z.number().nullable()
-        })
-    ),
-    pagination: z.object({
-        total: z.number(),
-        limit: z.number(),
-        offset: z.number()
-    })
-});
-
 registry.registerPath({
     method: "get",
     path: "/idp/{idpId}/org",
@@ -69,18 +53,7 @@ registry.registerPath({
         params: paramsSchema,
         query: querySchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(
-                        ListIdpOrgPoliciesResponseDataSchema
-                    )
-                }
-            }
-        }
-    }
 });
 
 export async function listIdpOrgPolicies(

server/routers/idp/listIdps.ts

@@ -9,7 +9,6 @@ import { eq, sql } from "drizzle-orm";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 
 const querySchema = z.strictObject({
     limit: z
@@ -55,25 +54,6 @@ export type ListIdpsResponse = {
     };
 };
 
-const ListIdpsResponseDataSchema = z.object({
-    idps: z.array(
-        z.object({
-            idpId: z.number(),
-            name: z.string(),
-            type: z.string(),
-            variant: z.string().nullable(),
-            orgCount: z.number(),
-            autoProvision: z.boolean().nullable(),
-            tags: z.string().nullable()
-        })
-    ),
-    pagination: z.object({
-        total: z.number(),
-        limit: z.number(),
-        offset: z.number()
-    })
-});
-
 registry.registerPath({
     method: "get",
     path: "/idp",
@@ -82,16 +62,7 @@ registry.registerPath({
     request: {
         query: querySchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(ListIdpsResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function listIdps(

server/routers/idp/updateIdpOrgPolicy.ts

@@ -1,6 +1,5 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { db } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
@@ -22,8 +21,6 @@ const bodySchema = z.strictObject({
 });
 
 export type UpdateIdpOrgPolicyResponse = {};
-const UpdateIdpOrgPolicyResponseDataSchema = z.object({});
-
 
 registry.registerPath({
     method: "post",
@@ -40,16 +37,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(UpdateIdpOrgPolicyResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function updateIdpOrgPolicy(

server/routers/idp/updateOidcIdp.ts

@@ -1,6 +1,5 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { db } from "@server/db";
 import response from "@server/lib/response";
 import HttpCode from "@server/types/HttpCode";
@@ -39,10 +38,6 @@ const bodySchema = z.strictObject({
 export type UpdateIdpResponse = {
     idpId: number;
 };
-const UpdateIdpResponseDataSchema = z.object({
-    idpId: z.number()
-});
-
 
 registry.registerPath({
     method: "post",
@@ -59,16 +54,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(UpdateIdpResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function updateOidcIdp(

server/routers/olm/createUserOlm.ts

@@ -43,22 +43,7 @@ export type CreateOlmResponse = {
 //         },
 //         params: paramsSchema
 //     },
-// responses: {
+//     responses: {}
-// 200: {
-// description: "Successful response",
-// content: {
-// "application/json": {
-// schema: z.object({
-// data: z.unknown().nullable(),
-// success: z.boolean(),
-// error: z.boolean(),
-// message: z.string(),
-// status: z.number()
-// })
-// }
-// }
-// }
-// }
 // });
 
 export async function createUserOlm(

server/routers/olm/deleteUserOlm.ts

@@ -28,22 +28,7 @@ const paramsSchema = z
 //     request: {
 //         params: paramsSchema
 //     },
-// responses: {
+//     responses: {}
-// 200: {
-// description: "Successful response",
-// content: {
-// "application/json": {
-// schema: z.object({
-// data: z.unknown().nullable(),
-// success: z.boolean(),
-// error: z.boolean(),
-// message: z.string(),
-// status: z.number()
-// })
-// }
-// }
-// }
-// }
 // });
 
 export async function deleteUserOlm(

server/routers/olm/getUserOlm.ts

@@ -30,22 +30,7 @@ const querySchema = z.object({
 //     request: {
 //         params: paramsSchema
 //     },
-// responses: {
+//     responses: {}
-// 200: {
-// description: "Successful response",
-// content: {
-// "application/json": {
-// schema: z.object({
-// data: z.unknown().nullable(),
-// success: z.boolean(),
-// error: z.boolean(),
-// message: z.string(),
-// status: z.number()
-// })
-// }
-// }
-// }
-// }
 // });
 
 export async function getUserOlm(

server/routers/olm/listUserOlms.ts

@@ -41,22 +41,7 @@ const paramsSchema = z
 //         query: querySchema,
 //         params: paramsSchema
 //     },
-// responses: {
+//     responses: {}
-// 200: {
-// description: "Successful response",
-// content: {
-// "application/json": {
-// schema: z.object({
-// data: z.unknown().nullable(),
-// success: z.boolean(),
-// error: z.boolean(),
-// message: z.string(),
-// status: z.number()
-// })
-// }
-// }
-// }
-// }
 // });
 
 export type ListUserOlmsResponse = {

server/routers/org/checkOrgUserAccess.ts

@@ -83,22 +83,7 @@ registry.registerPath({
     request: {
         params: paramsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function checkOrgUserAccess(

server/routers/org/createOrg.ts

@@ -74,22 +74,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function createOrg(

server/routers/org/deleteOrg.ts

@@ -24,22 +24,7 @@ registry.registerPath({
     request: {
         params: deleteOrgSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function deleteOrg(

server/routers/org/getOrg.ts

@@ -1,6 +1,5 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 import { db } from "@server/db";
 import { Org, orgs } from "@server/db";
 import { eq } from "drizzle-orm";
@@ -18,10 +17,6 @@ const getOrgSchema = z.strictObject({
 export type GetOrgResponse = {
     org: Org;
 };
-const GetOrgResponseDataSchema = z.object({
-    org: z.object({}).passthrough()
-});
-
 
 registry.registerPath({
     method: "get",
@@ -31,16 +26,7 @@ registry.registerPath({
     request: {
         params: getOrgSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(GetOrgResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export async function getOrg(

server/routers/org/listOrgs.ts

@@ -9,7 +9,6 @@ import { sql, inArray, eq } from "drizzle-orm";
 import logger from "@server/logger";
 import { fromZodError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
-import { createApiResponseSchema } from "@server/lib/openapi/createApiResponseSchema";
 
 const listOrgsSchema = z.object({
     limit: z
@@ -34,16 +33,7 @@ registry.registerPath({
     request: {
         query: listOrgsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: createApiResponseSchema(ListOrgsResponseDataSchema)
-                }
-            }
-        }
-    }
 });
 
 export type ListOrgsResponse = {
@@ -51,15 +41,6 @@ export type ListOrgsResponse = {
     pagination: { total: number; limit: number; offset: number };
 };
 
-const ListOrgsResponseDataSchema = z.object({
-    orgs: z.array(z.object({}).passthrough()),
-    pagination: z.object({
-        total: z.number(),
-        limit: z.number(),
-        offset: z.number()
-    })
-});
-
 export async function listOrgs(
     req: Request,
     res: Response,

server/routers/org/listUserOrgs.ts

@@ -37,22 +37,7 @@ const listOrgsSchema = z.object({
 //     request: {
 //         query: listOrgsSchema
 //     },
-// responses: {
+//     responses: {}
-// 200: {
-// description: "Successful response",
-// content: {
-// "application/json": {
-// schema: z.object({
-// data: z.unknown().nullable(),
-// success: z.boolean(),
-// error: z.boolean(),
-// message: z.string(),
-// status: z.number()
-// })
-// }
-// }
-// }
-// }
 // });
 
 type ResponseOrg = Org & {

server/routers/org/resetOrgBandwidth.ts

@@ -21,22 +21,7 @@ registry.registerPath({
     request: {
         params: resetOrgBandwidthParamsSchema
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function resetOrgBandwidth(

server/routers/org/updateOrg.ts

@@ -61,22 +61,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function updateOrg(

server/routers/resource/addEmailToResourceWhitelist.ts

@@ -22,7 +22,7 @@ const addEmailToResourceWhitelistBodySchema = z.strictObject({
 });
 
 const addEmailToResourceWhitelistParamsSchema = z.strictObject({
-    resourceId: z.coerce.number().int().positive()
+    resourceId: z.string().transform(Number).pipe(z.int().positive())
 });
 
 registry.registerPath({
@@ -40,22 +40,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function addEmailToResourceWhitelist(

server/routers/resource/addRoleToResource.ts

@@ -40,22 +40,7 @@ registry.registerPath({
             }
         }
     },
-    responses: {
+    responses: {}
-        200: {
-            description: "Successful response",
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        data: z.unknown().nullable(),
-                        success: z.boolean(),
-                        error: z.boolean(),
-                        message: z.string(),
-                        status: z.number()
-                    })
-                }
-            }
-        }
-    }
 });
 
 export async function addRoleToResource(