@layer-drone/protocol 0.8.0 → 1.0.0

package/src/client/types.gen.ts

@@ -1074,49 +1074,148 @@ export type DeleteInboundWebhookConfigResponse = {
   message: string;
 };
 
-export type ApiControllerGetHelloData = {
+export type ApiControllerGetHello0V1Data = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: "/v1";
+};
+
+export type ApiControllerGetHello0V1Responses = {
+  200: unknown;
+};
+
+export type ApiControllerGetHello1Data = {
   body?: never;
   path?: never;
   query?: never;
   url: "/";
 };
 
-export type ApiControllerGetHelloResponses = {
+export type ApiControllerGetHello1Responses = {
+  200: unknown;
+};
+
+export type ApiControllerGetError0V1Data = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: "/v1/debug-sentry";
+};
+
+export type ApiControllerGetError0V1Responses = {
   200: unknown;
 };
 
-export type ApiControllerGetErrorData = {
+export type ApiControllerGetError1Data = {
   body?: never;
   path?: never;
   query?: never;
   url: "/debug-sentry";
 };
 
-export type ApiControllerGetErrorResponses = {
+export type ApiControllerGetError1Responses = {
   200: unknown;
 };
 
-export type ApiTokenControllerCreateTokenData = {
+export type ApiTokenControllerCreateToken0V1Data = {
+  body: CreateApiTokenRequestDto;
+  path?: never;
+  query?: never;
+  url: "/v1/tokens";
+};
+
+export type ApiTokenControllerCreateToken0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type ApiTokenControllerCreateToken0V1Responses = {
+  200: CreateApiTokenResponseDto;
+  201: unknown;
+};
+
+export type ApiTokenControllerCreateToken0V1Response =
+  ApiTokenControllerCreateToken0V1Responses[keyof ApiTokenControllerCreateToken0V1Responses];
+
+export type ApiTokenControllerCreateToken1Data = {
   body: CreateApiTokenRequestDto;
   path?: never;
   query?: never;
   url: "/tokens";
 };
 
-export type ApiTokenControllerCreateTokenErrors = {
+export type ApiTokenControllerCreateToken1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type ApiTokenControllerCreateTokenResponses = {
+export type ApiTokenControllerCreateToken1Responses = {
   200: CreateApiTokenResponseDto;
   201: unknown;
 };
 
-export type ApiTokenControllerCreateTokenResponse =
-  ApiTokenControllerCreateTokenResponses[keyof ApiTokenControllerCreateTokenResponses];
+export type ApiTokenControllerCreateToken1Response =
+  ApiTokenControllerCreateToken1Responses[keyof ApiTokenControllerCreateToken1Responses];
+
+export type ApiTokenControllerDeleteToken0V1Data = {
+  body?: never;
+  path: {
+    id: string;
+  };
+  query?: never;
+  url: "/v1/tokens/{id}";
+};
+
+export type ApiTokenControllerDeleteToken0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type ApiTokenControllerDeleteToken0V1Responses = {
+  200: unknown;
+};
+
+export type ApiTokenControllerGetToken0V1Data = {
+  body?: never;
+  path: {
+    id: string;
+  };
+  query?: never;
+  url: "/v1/tokens/{id}";
+};
+
+export type ApiTokenControllerGetToken0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type ApiTokenControllerGetToken0V1Responses = {
+  200: unknown;
+};
+
+export type ApiTokenControllerUpdateToken0V1Data = {
+  body: UpdateApiTokenRequestDto;
+  path: {
+    id: string;
+  };
+  query?: never;
+  url: "/v1/tokens/{id}";
+};
+
+export type ApiTokenControllerUpdateToken0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type ApiTokenControllerUpdateToken0V1Responses = {
+  200: UpdateApiTokenResponseDto;
+};
+
+export type ApiTokenControllerUpdateToken0V1Response =
+  ApiTokenControllerUpdateToken0V1Responses[keyof ApiTokenControllerUpdateToken0V1Responses];
 
-export type ApiTokenControllerDeleteTokenData = {
+export type ApiTokenControllerDeleteToken1Data = {
   body?: never;
   path: {
     id: string;
@@ -1125,16 +1224,16 @@ export type ApiTokenControllerDeleteTokenData = {
   url: "/tokens/{id}";
 };
 
-export type ApiTokenControllerDeleteTokenErrors = {
+export type ApiTokenControllerDeleteToken1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type ApiTokenControllerDeleteTokenResponses = {
+export type ApiTokenControllerDeleteToken1Responses = {
   200: unknown;
 };
 
-export type ApiTokenControllerGetTokenData = {
+export type ApiTokenControllerGetToken1Data = {
   body?: never;
   path: {
     id: string;
@@ -1143,16 +1242,16 @@ export type ApiTokenControllerGetTokenData = {
   url: "/tokens/{id}";
 };
 
-export type ApiTokenControllerGetTokenErrors = {
+export type ApiTokenControllerGetToken1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type ApiTokenControllerGetTokenResponses = {
+export type ApiTokenControllerGetToken1Responses = {
   200: unknown;
 };
 
-export type ApiTokenControllerUpdateTokenData = {
+export type ApiTokenControllerUpdateToken1Data = {
   body: UpdateApiTokenRequestDto;
   path: {
     id: string;
@@ -1161,19 +1260,49 @@ export type ApiTokenControllerUpdateTokenData = {
   url: "/tokens/{id}";
 };
 
-export type ApiTokenControllerUpdateTokenErrors = {
+export type ApiTokenControllerUpdateToken1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type ApiTokenControllerUpdateTokenResponses = {
+export type ApiTokenControllerUpdateToken1Responses = {
   200: UpdateApiTokenResponseDto;
 };
 
-export type ApiTokenControllerUpdateTokenResponse =
-  ApiTokenControllerUpdateTokenResponses[keyof ApiTokenControllerUpdateTokenResponses];
+export type ApiTokenControllerUpdateToken1Response =
+  ApiTokenControllerUpdateToken1Responses[keyof ApiTokenControllerUpdateToken1Responses];
+
+export type ConditionsControllerGetSunAltitudeTimeLimits0V1Data = {
+  body?: never;
+  path?: never;
+  query: {
+    /**
+     * Latitude in degress (decimal number)
+     */
+    lat: number;
+    /**
+     * Longitude in degress (decimal number)
+     */
+    lon: number;
+    /**
+     * Local time in ISO time format with correct timezone YYYY-MM-DDTHH:MM:SS+hh:mm
+     */
+    time: Date;
+  };
+  url: "/v1/conditions/sun-altitude";
+};
+
+export type ConditionsControllerGetSunAltitudeTimeLimits0V1Responses = {
+  /**
+   * Returns sun altitude time limits for given coordinates and time
+   */
+  200: GetTimeLimitsForSunAltitudeResponse;
+};
+
+export type ConditionsControllerGetSunAltitudeTimeLimits0V1Response =
+  ConditionsControllerGetSunAltitudeTimeLimits0V1Responses[keyof ConditionsControllerGetSunAltitudeTimeLimits0V1Responses];
 
-export type ConditionsControllerGetSunAltitudeTimeLimitsData = {
+export type ConditionsControllerGetSunAltitudeTimeLimits1Data = {
   body?: never;
   path?: never;
   query: {
@@ -1193,46 +1322,98 @@ export type ConditionsControllerGetSunAltitudeTimeLimitsData = {
   url: "/conditions/sun-altitude";
 };
 
-export type ConditionsControllerGetSunAltitudeTimeLimitsResponses = {
+export type ConditionsControllerGetSunAltitudeTimeLimits1Responses = {
   /**
    * Returns sun altitude time limits for given coordinates and time
    */
   200: GetTimeLimitsForSunAltitudeResponse;
 };
 
-export type ConditionsControllerGetSunAltitudeTimeLimitsResponse =
-  ConditionsControllerGetSunAltitudeTimeLimitsResponses[keyof ConditionsControllerGetSunAltitudeTimeLimitsResponses];
+export type ConditionsControllerGetSunAltitudeTimeLimits1Response =
+  ConditionsControllerGetSunAltitudeTimeLimits1Responses[keyof ConditionsControllerGetSunAltitudeTimeLimits1Responses];
+
+export type ContractsControllerGetAllContracts0V1Data = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: "/v1/contracts";
+};
+
+export type ContractsControllerGetAllContracts0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type ContractsControllerGetAllContracts0V1Responses = {
+  /**
+   * Contracts retrieved successfully
+   */
+  200: GetContractsResponseDto;
+};
+
+export type ContractsControllerGetAllContracts0V1Response =
+  ContractsControllerGetAllContracts0V1Responses[keyof ContractsControllerGetAllContracts0V1Responses];
+
+export type ContractsControllerCreateContract0V1Data = {
+  body: CreateContractRequestDto;
+  path?: never;
+  query?: never;
+  url: "/v1/contracts";
+};
+
+export type ContractsControllerCreateContract0V1Errors = {
+  /**
+   * Validation failed
+   */
+  400: unknown;
+  401: unknown;
+  403: unknown;
+  /**
+   * Contract with this address already exists
+   */
+  409: unknown;
+};
+
+export type ContractsControllerCreateContract0V1Responses = {
+  /**
+   * Contract created successfully
+   */
+  201: CreateContractResponseDto;
+};
+
+export type ContractsControllerCreateContract0V1Response =
+  ContractsControllerCreateContract0V1Responses[keyof ContractsControllerCreateContract0V1Responses];
 
-export type ContractsControllerGetAllContractsData = {
+export type ContractsControllerGetAllContracts1Data = {
   body?: never;
   path?: never;
   query?: never;
   url: "/contracts";
 };
 
-export type ContractsControllerGetAllContractsErrors = {
+export type ContractsControllerGetAllContracts1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type ContractsControllerGetAllContractsResponses = {
+export type ContractsControllerGetAllContracts1Responses = {
   /**
    * Contracts retrieved successfully
    */
   200: GetContractsResponseDto;
 };
 
-export type ContractsControllerGetAllContractsResponse =
-  ContractsControllerGetAllContractsResponses[keyof ContractsControllerGetAllContractsResponses];
+export type ContractsControllerGetAllContracts1Response =
+  ContractsControllerGetAllContracts1Responses[keyof ContractsControllerGetAllContracts1Responses];
 
-export type ContractsControllerCreateContractData = {
+export type ContractsControllerCreateContract1Data = {
   body: CreateContractRequestDto;
   path?: never;
   query?: never;
   url: "/contracts";
 };
 
-export type ContractsControllerCreateContractErrors = {
+export type ContractsControllerCreateContract1Errors = {
   /**
    * Validation failed
    */
@@ -1245,26 +1426,26 @@ export type ContractsControllerCreateContractErrors = {
   409: unknown;
 };
 
-export type ContractsControllerCreateContractResponses = {
+export type ContractsControllerCreateContract1Responses = {
   /**
    * Contract created successfully
    */
   201: CreateContractResponseDto;
 };
 
-export type ContractsControllerCreateContractResponse =
-  ContractsControllerCreateContractResponses[keyof ContractsControllerCreateContractResponses];
+export type ContractsControllerCreateContract1Response =
+  ContractsControllerCreateContract1Responses[keyof ContractsControllerCreateContract1Responses];
 
-export type ContractsControllerDeleteContractData = {
+export type ContractsControllerDeleteContract0V1Data = {
   body?: never;
   path: {
     id: number;
   };
   query?: never;
-  url: "/contracts/{id}";
+  url: "/v1/contracts/{id}";
 };
 
-export type ContractsControllerDeleteContractErrors = {
+export type ContractsControllerDeleteContract0V1Errors = {
   401: unknown;
   403: unknown;
   /**
@@ -1273,26 +1454,26 @@ export type ContractsControllerDeleteContractErrors = {
   404: unknown;
 };
 
-export type ContractsControllerDeleteContractResponses = {
+export type ContractsControllerDeleteContract0V1Responses = {
   /**
    * Contract deleted successfully
    */
   200: DeleteContractResponseDto;
 };
 
-export type ContractsControllerDeleteContractResponse =
-  ContractsControllerDeleteContractResponses[keyof ContractsControllerDeleteContractResponses];
+export type ContractsControllerDeleteContract0V1Response =
+  ContractsControllerDeleteContract0V1Responses[keyof ContractsControllerDeleteContract0V1Responses];
 
-export type ContractsControllerGetContractData = {
+export type ContractsControllerGetContract0V1Data = {
   body?: never;
   path: {
     id: number;
   };
   query?: never;
-  url: "/contracts/{id}";
+  url: "/v1/contracts/{id}";
 };
 
-export type ContractsControllerGetContractErrors = {
+export type ContractsControllerGetContract0V1Errors = {
   401: unknown;
   403: unknown;
   /**
@@ -1301,26 +1482,26 @@ export type ContractsControllerGetContractErrors = {
   404: unknown;
 };
 
-export type ContractsControllerGetContractResponses = {
+export type ContractsControllerGetContract0V1Responses = {
   /**
    * Contract retrieved successfully
    */
   200: GetContractResponseDto;
 };
 
-export type ContractsControllerGetContractResponse =
-  ContractsControllerGetContractResponses[keyof ContractsControllerGetContractResponses];
+export type ContractsControllerGetContract0V1Response =
+  ContractsControllerGetContract0V1Responses[keyof ContractsControllerGetContract0V1Responses];
 
-export type ContractsControllerUpdateContractData = {
+export type ContractsControllerUpdateContract0V1Data = {
   body: UpdateContractRequestDto;
   path: {
     id: number;
   };
   query?: never;
-  url: "/contracts/{id}";
+  url: "/v1/contracts/{id}";
 };
 
-export type ContractsControllerUpdateContractErrors = {
+export type ContractsControllerUpdateContract0V1Errors = {
   401: unknown;
   403: unknown;
   /**
@@ -1333,200 +1514,496 @@ export type ContractsControllerUpdateContractErrors = {
   409: unknown;
 };
 
-export type ContractsControllerUpdateContractResponses = {
+export type ContractsControllerUpdateContract0V1Responses = {
   /**
    * Contract updated successfully
    */
   200: UpdateContractResponseDto;
 };
 
-export type ContractsControllerUpdateContractResponse =
-  ContractsControllerUpdateContractResponses[keyof ContractsControllerUpdateContractResponses];
+export type ContractsControllerUpdateContract0V1Response =
+  ContractsControllerUpdateContract0V1Responses[keyof ContractsControllerUpdateContract0V1Responses];
 
-export type DlqRedriverControllerRedriveDlqData = {
-  body: RedriveDlqRequestDto;
-  path?: never;
+export type ContractsControllerDeleteContract1Data = {
+  body?: never;
+  path: {
+    id: number;
+  };
   query?: never;
-  url: "/dlq-redriver/redrive";
+  url: "/contracts/{id}";
 };
 
-export type DlqRedriverControllerRedriveDlqErrors = {
-  /**
-   * Invalid request parameters
-   */
-  400: unknown;
+export type ContractsControllerDeleteContract1Errors = {
   401: unknown;
   403: unknown;
   /**
-   * Error during DLQ redrive
+   * Contract not found
    */
-  500: unknown;
+  404: unknown;
 };
 
-export type DlqRedriverControllerRedriveDlqResponses = {
+export type ContractsControllerDeleteContract1Responses = {
   /**
-   * DLQ redrive completed successfully
+   * Contract deleted successfully
    */
-  200: RedriveDlqResponseDto;
+  200: DeleteContractResponseDto;
 };
 
-export type DlqRedriverControllerRedriveDlqResponse =
-  DlqRedriverControllerRedriveDlqResponses[keyof DlqRedriverControllerRedriveDlqResponses];
+export type ContractsControllerDeleteContract1Response =
+  ContractsControllerDeleteContract1Responses[keyof ContractsControllerDeleteContract1Responses];
 
-export type FlightsControllerGenerateStorageKeyData = {
+export type ContractsControllerGetContract1Data = {
   body?: never;
-  path?: never;
-  query: {
-    missionId: string | number | bigint;
-    pilotAddress: string;
-    flightTimestamp?: string;
+  path: {
+    id: number;
   };
-  url: "/flights/storage-key";
+  query?: never;
+  url: "/contracts/{id}";
 };
 
-export type FlightsControllerGenerateStorageKeyErrors = {
+export type ContractsControllerGetContract1Errors = {
   401: unknown;
   403: unknown;
+  /**
+   * Contract not found
+   */
+  404: unknown;
 };
 
-export type FlightsControllerGenerateStorageKeyResponses = {
+export type ContractsControllerGetContract1Responses = {
   /**
-   * Returns the generated storage key
+   * Contract retrieved successfully
    */
-  200: string;
+  200: GetContractResponseDto;
 };
 
-export type FlightsControllerGenerateStorageKeyResponse =
-  FlightsControllerGenerateStorageKeyResponses[keyof FlightsControllerGenerateStorageKeyResponses];
+export type ContractsControllerGetContract1Response =
+  ContractsControllerGetContract1Responses[keyof ContractsControllerGetContract1Responses];
 
-export type FlightsControllerGetFlightData = {
-  body?: never;
+export type ContractsControllerUpdateContract1Data = {
+  body: UpdateContractRequestDto;
   path: {
-    flightId: bigint;
+    id: number;
   };
   query?: never;
-  url: "/flights/{flightId}";
+  url: "/contracts/{id}";
 };
 
-export type FlightsControllerGetFlightErrors = {
+export type ContractsControllerUpdateContract1Errors = {
   401: unknown;
   403: unknown;
+  /**
+   * Contract not found
+   */
+  404: unknown;
+  /**
+   * Contract with this address already exists
+   */
+  409: unknown;
 };
 
-export type FlightsControllerGetFlightResponses = {
+export type ContractsControllerUpdateContract1Responses = {
   /**
-   * Returns flight details
+   * Contract updated successfully
    */
-  200: FlightDto;
+  200: UpdateContractResponseDto;
 };
 
-export type FlightsControllerGetFlightResponse =
-  FlightsControllerGetFlightResponses[keyof FlightsControllerGetFlightResponses];
+export type ContractsControllerUpdateContract1Response =
+  ContractsControllerUpdateContract1Responses[keyof ContractsControllerUpdateContract1Responses];
 
-export type FlightsControllerCreatePresignedUrlsData = {
-  body: CreateFileRequestDto;
+export type DlqRedriverControllerRedriveDlq0V1Data = {
+  body: RedriveDlqRequestDto;
   path?: never;
   query?: never;
-  url: "/flights/files";
+  url: "/v1/dlq-redriver/redrive";
 };
 
-export type FlightsControllerCreatePresignedUrlsErrors = {
+export type DlqRedriverControllerRedriveDlq0V1Errors = {
+  /**
+   * Invalid request parameters
+   */
+  400: unknown;
   401: unknown;
   403: unknown;
+  /**
+   * Error during DLQ redrive
+   */
+  500: unknown;
 };
 
-export type FlightsControllerCreatePresignedUrlsResponses = {
+export type DlqRedriverControllerRedriveDlq0V1Responses = {
   /**
-   * Returns presigned URLs for file upload
+   * DLQ redrive completed successfully
    */
-  201: CreateFileResponseDto;
+  200: RedriveDlqResponseDto;
 };
 
-export type FlightsControllerCreatePresignedUrlsResponse =
-  FlightsControllerCreatePresignedUrlsResponses[keyof FlightsControllerCreatePresignedUrlsResponses];
+export type DlqRedriverControllerRedriveDlq0V1Response =
+  DlqRedriverControllerRedriveDlq0V1Responses[keyof DlqRedriverControllerRedriveDlq0V1Responses];
 
-export type FlightsControllerValidateFlightData = {
-  body: ValidateFlightRequestDto;
+export type DlqRedriverControllerRedriveDlq1Data = {
+  body: RedriveDlqRequestDto;
   path?: never;
   query?: never;
-  url: "/flights";
+  url: "/dlq-redriver/redrive";
 };
 
-export type FlightsControllerValidateFlightErrors = {
+export type DlqRedriverControllerRedriveDlq1Errors = {
+  /**
+   * Invalid request parameters
+   */
+  400: unknown;
   401: unknown;
   403: unknown;
+  /**
+   * Error during DLQ redrive
+   */
+  500: unknown;
 };
 
-export type FlightsControllerValidateFlightResponses = {
+export type DlqRedriverControllerRedriveDlq1Responses = {
   /**
-   * Result to track queued flight through its validation
+   * DLQ redrive completed successfully
    */
-  200: ValidateFlightResponseDto;
+  200: RedriveDlqResponseDto;
 };
 
-export type FlightsControllerValidateFlightResponse =
-  FlightsControllerValidateFlightResponses[keyof FlightsControllerValidateFlightResponses];
+export type DlqRedriverControllerRedriveDlq1Response =
+  DlqRedriverControllerRedriveDlq1Responses[keyof DlqRedriverControllerRedriveDlq1Responses];
 
-export type FlightPlansControllerGetManyData = {
+export type FlightsControllerGenerateStorageKey0V1Data = {
   body?: never;
   path?: never;
-  query?: never;
-  url: "/flight-plans";
+  query: {
+    missionId: string | number | bigint;
+    pilotAddress: string;
+    flightTimestamp?: string;
+  };
+  url: "/v1/flights/storage-key";
 };
 
-export type FlightPlansControllerGetManyErrors = {
+export type FlightsControllerGenerateStorageKey0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type FlightPlansControllerGetManyResponses = {
-  200: GetFlightPlansResponse;
+export type FlightsControllerGenerateStorageKey0V1Responses = {
+  /**
+   * Returns the generated storage key
+   */
+  200: string;
 };
 
-export type FlightPlansControllerGetManyResponse =
-  FlightPlansControllerGetManyResponses[keyof FlightPlansControllerGetManyResponses];
+export type FlightsControllerGenerateStorageKey0V1Response =
+  FlightsControllerGenerateStorageKey0V1Responses[keyof FlightsControllerGenerateStorageKey0V1Responses];
 
-export type FlightPlansControllerCreateData = {
-  body: CreateFlightPlanBody;
+export type FlightsControllerGenerateStorageKey1Data = {
+  body?: never;
   path?: never;
-  query?: never;
-  url: "/flight-plans";
+  query: {
+    missionId: string | number | bigint;
+    pilotAddress: string;
+    flightTimestamp?: string;
+  };
+  url: "/flights/storage-key";
 };
 
-export type FlightPlansControllerCreateErrors = {
+export type FlightsControllerGenerateStorageKey1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type FlightPlansControllerCreateResponses = {
-  201: CreateFlightPlanResponse;
+export type FlightsControllerGenerateStorageKey1Responses = {
+  /**
+   * Returns the generated storage key
+   */
+  200: string;
 };
 
-export type FlightPlansControllerCreateResponse =
-  FlightPlansControllerCreateResponses[keyof FlightPlansControllerCreateResponses];
+export type FlightsControllerGenerateStorageKey1Response =
+  FlightsControllerGenerateStorageKey1Responses[keyof FlightsControllerGenerateStorageKey1Responses];
 
-export type FlightPlansControllerGetData = {
+export type FlightsControllerGetFlight0V1Data = {
   body?: never;
   path: {
-    id: number;
+    flightId: bigint;
+  };
+  query?: never;
+  url: "/v1/flights/{flightId}";
+};
+
+export type FlightsControllerGetFlight0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightsControllerGetFlight0V1Responses = {
+  /**
+   * Returns flight details
+   */
+  200: FlightDto;
+};
+
+export type FlightsControllerGetFlight0V1Response =
+  FlightsControllerGetFlight0V1Responses[keyof FlightsControllerGetFlight0V1Responses];
+
+export type FlightsControllerGetFlight1Data = {
+  body?: never;
+  path: {
+    flightId: bigint;
+  };
+  query?: never;
+  url: "/flights/{flightId}";
+};
+
+export type FlightsControllerGetFlight1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightsControllerGetFlight1Responses = {
+  /**
+   * Returns flight details
+   */
+  200: FlightDto;
+};
+
+export type FlightsControllerGetFlight1Response =
+  FlightsControllerGetFlight1Responses[keyof FlightsControllerGetFlight1Responses];
+
+export type FlightsControllerCreatePresignedUrls0V1Data = {
+  body: CreateFileRequestDto;
+  path?: never;
+  query?: never;
+  url: "/v1/flights/files";
+};
+
+export type FlightsControllerCreatePresignedUrls0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightsControllerCreatePresignedUrls0V1Responses = {
+  /**
+   * Returns presigned URLs for file upload
+   */
+  201: CreateFileResponseDto;
+};
+
+export type FlightsControllerCreatePresignedUrls0V1Response =
+  FlightsControllerCreatePresignedUrls0V1Responses[keyof FlightsControllerCreatePresignedUrls0V1Responses];
+
+export type FlightsControllerCreatePresignedUrls1Data = {
+  body: CreateFileRequestDto;
+  path?: never;
+  query?: never;
+  url: "/flights/files";
+};
+
+export type FlightsControllerCreatePresignedUrls1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightsControllerCreatePresignedUrls1Responses = {
+  /**
+   * Returns presigned URLs for file upload
+   */
+  201: CreateFileResponseDto;
+};
+
+export type FlightsControllerCreatePresignedUrls1Response =
+  FlightsControllerCreatePresignedUrls1Responses[keyof FlightsControllerCreatePresignedUrls1Responses];
+
+export type FlightsControllerValidateFlight0V1Data = {
+  body: ValidateFlightRequestDto;
+  path?: never;
+  query?: never;
+  url: "/v1/flights";
+};
+
+export type FlightsControllerValidateFlight0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightsControllerValidateFlight0V1Responses = {
+  /**
+   * Result to track queued flight through its validation
+   */
+  200: ValidateFlightResponseDto;
+};
+
+export type FlightsControllerValidateFlight0V1Response =
+  FlightsControllerValidateFlight0V1Responses[keyof FlightsControllerValidateFlight0V1Responses];
+
+export type FlightsControllerValidateFlight1Data = {
+  body: ValidateFlightRequestDto;
+  path?: never;
+  query?: never;
+  url: "/flights";
+};
+
+export type FlightsControllerValidateFlight1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightsControllerValidateFlight1Responses = {
+  /**
+   * Result to track queued flight through its validation
+   */
+  200: ValidateFlightResponseDto;
+};
+
+export type FlightsControllerValidateFlight1Response =
+  FlightsControllerValidateFlight1Responses[keyof FlightsControllerValidateFlight1Responses];
+
+export type FlightPlansControllerGetMany0V1Data = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: "/v1/flight-plans";
+};
+
+export type FlightPlansControllerGetMany0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightPlansControllerGetMany0V1Responses = {
+  200: GetFlightPlansResponse;
+};
+
+export type FlightPlansControllerGetMany0V1Response =
+  FlightPlansControllerGetMany0V1Responses[keyof FlightPlansControllerGetMany0V1Responses];
+
+export type FlightPlansControllerCreate0V1Data = {
+  body: CreateFlightPlanBody;
+  path?: never;
+  query?: never;
+  url: "/v1/flight-plans";
+};
+
+export type FlightPlansControllerCreate0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightPlansControllerCreate0V1Responses = {
+  201: CreateFlightPlanResponse;
+};
+
+export type FlightPlansControllerCreate0V1Response =
+  FlightPlansControllerCreate0V1Responses[keyof FlightPlansControllerCreate0V1Responses];
+
+export type FlightPlansControllerGetMany1Data = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: "/flight-plans";
+};
+
+export type FlightPlansControllerGetMany1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightPlansControllerGetMany1Responses = {
+  200: GetFlightPlansResponse;
+};
+
+export type FlightPlansControllerGetMany1Response =
+  FlightPlansControllerGetMany1Responses[keyof FlightPlansControllerGetMany1Responses];
+
+export type FlightPlansControllerCreate1Data = {
+  body: CreateFlightPlanBody;
+  path?: never;
+  query?: never;
+  url: "/flight-plans";
+};
+
+export type FlightPlansControllerCreate1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightPlansControllerCreate1Responses = {
+  201: CreateFlightPlanResponse;
+};
+
+export type FlightPlansControllerCreate1Response =
+  FlightPlansControllerCreate1Responses[keyof FlightPlansControllerCreate1Responses];
+
+export type FlightPlansControllerGet0V1Data = {
+  body?: never;
+  path: {
+    id: number;
+  };
+  query?: never;
+  url: "/v1/flight-plans/{id}";
+};
+
+export type FlightPlansControllerGet0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightPlansControllerGet0V1Responses = {
+  200: GetFlightPlanResponse;
+};
+
+export type FlightPlansControllerGet0V1Response =
+  FlightPlansControllerGet0V1Responses[keyof FlightPlansControllerGet0V1Responses];
+
+export type FlightPlansControllerGet1Data = {
+  body?: never;
+  path: {
+    id: number;
   };
   query?: never;
   url: "/flight-plans/{id}";
 };
 
-export type FlightPlansControllerGetErrors = {
+export type FlightPlansControllerGet1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type FlightPlansControllerGetResponses = {
+export type FlightPlansControllerGet1Responses = {
   200: GetFlightPlanResponse;
 };
 
-export type FlightPlansControllerGetResponse =
-  FlightPlansControllerGetResponses[keyof FlightPlansControllerGetResponses];
+export type FlightPlansControllerGet1Response =
+  FlightPlansControllerGet1Responses[keyof FlightPlansControllerGet1Responses];
+
+export type FlightReviewsControllerGetFlightReview0V1Data = {
+  body?: never;
+  path: {
+    id: bigint;
+  };
+  query?: never;
+  url: "/v1/flight-reviews/{id}";
+};
+
+export type FlightReviewsControllerGetFlightReview0V1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Flight review not found
+   */
+  404: unknown;
+};
+
+export type FlightReviewsControllerGetFlightReview0V1Responses = {
+  200: GetFlightReviewResponseDto;
+};
+
+export type FlightReviewsControllerGetFlightReview0V1Response =
+  FlightReviewsControllerGetFlightReview0V1Responses[keyof FlightReviewsControllerGetFlightReview0V1Responses];
 
-export type FlightReviewsControllerGetFlightReviewData = {
+export type FlightReviewsControllerGetFlightReview1Data = {
   body?: never;
   path: {
     id: bigint;
@@ -1535,7 +2012,7 @@ export type FlightReviewsControllerGetFlightReviewData = {
   url: "/flight-reviews/{id}";
 };
 
-export type FlightReviewsControllerGetFlightReviewErrors = {
+export type FlightReviewsControllerGetFlightReview1Errors = {
   401: unknown;
   403: unknown;
   /**
@@ -1544,14 +2021,36 @@ export type FlightReviewsControllerGetFlightReviewErrors = {
   404: unknown;
 };
 
-export type FlightReviewsControllerGetFlightReviewResponses = {
+export type FlightReviewsControllerGetFlightReview1Responses = {
   200: GetFlightReviewResponseDto;
 };
 
-export type FlightReviewsControllerGetFlightReviewResponse =
-  FlightReviewsControllerGetFlightReviewResponses[keyof FlightReviewsControllerGetFlightReviewResponses];
+export type FlightReviewsControllerGetFlightReview1Response =
+  FlightReviewsControllerGetFlightReview1Responses[keyof FlightReviewsControllerGetFlightReview1Responses];
 
-export type FlightReviewsControllerGetFlightReviewsData = {
+export type FlightReviewsControllerGetFlightReviews0V1Data = {
+  body?: never;
+  path?: never;
+  query: {
+    updated_at_gt: Date;
+    updated_at_lt: Date;
+  };
+  url: "/v1/flight-reviews";
+};
+
+export type FlightReviewsControllerGetFlightReviews0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightReviewsControllerGetFlightReviews0V1Responses = {
+  200: GetFlightReviewsResponseDto;
+};
+
+export type FlightReviewsControllerGetFlightReviews0V1Response =
+  FlightReviewsControllerGetFlightReviews0V1Responses[keyof FlightReviewsControllerGetFlightReviews0V1Responses];
+
+export type FlightReviewsControllerGetFlightReviews1Data = {
   body?: never;
   path?: never;
   query: {
@@ -1561,33 +2060,78 @@ export type FlightReviewsControllerGetFlightReviewsData = {
   url: "/flight-reviews";
 };
 
-export type FlightReviewsControllerGetFlightReviewsErrors = {
+export type FlightReviewsControllerGetFlightReviews1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type FlightReviewsControllerGetFlightReviewsResponses = {
+export type FlightReviewsControllerGetFlightReviews1Responses = {
   200: GetFlightReviewsResponseDto;
 };
 
-export type FlightReviewsControllerGetFlightReviewsResponse =
-  FlightReviewsControllerGetFlightReviewsResponses[keyof FlightReviewsControllerGetFlightReviewsResponses];
+export type FlightReviewsControllerGetFlightReviews1Response =
+  FlightReviewsControllerGetFlightReviews1Responses[keyof FlightReviewsControllerGetFlightReviews1Responses];
 
-export type KeysControllerGetProvenanceCryptoKeyData = {
+export type KeysControllerGetProvenanceCryptoKey0V1Data = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: "/v1/keys";
+};
+
+export type KeysControllerGetProvenanceCryptoKey0V1Responses = {
+  200: GetProvenanceCryptoKeyResponse;
+};
+
+export type KeysControllerGetProvenanceCryptoKey0V1Response =
+  KeysControllerGetProvenanceCryptoKey0V1Responses[keyof KeysControllerGetProvenanceCryptoKey0V1Responses];
+
+export type KeysControllerGetProvenanceCryptoKey1Data = {
   body?: never;
   path?: never;
   query?: never;
   url: "/keys";
 };
 
-export type KeysControllerGetProvenanceCryptoKeyResponses = {
+export type KeysControllerGetProvenanceCryptoKey1Responses = {
   200: GetProvenanceCryptoKeyResponse;
 };
 
-export type KeysControllerGetProvenanceCryptoKeyResponse =
-  KeysControllerGetProvenanceCryptoKeyResponses[keyof KeysControllerGetProvenanceCryptoKeyResponses];
+export type KeysControllerGetProvenanceCryptoKey1Response =
+  KeysControllerGetProvenanceCryptoKey1Responses[keyof KeysControllerGetProvenanceCryptoKey1Responses];
+
+export type MissionsControllerGetMission0V1Data = {
+  body?: never;
+  path: {
+    id: string;
+  };
+  query?: {
+    relations?:
+      | "vault"
+      | "payout"
+      | "campaigns"
+      | Array<"vault" | "payout" | "campaigns">;
+  };
+  url: "/v1/missions/{id}";
+};
+
+export type MissionsControllerGetMission0V1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Mission not found
+   */
+  404: unknown;
+};
+
+export type MissionsControllerGetMission0V1Responses = {
+  200: GetMissionResponseDto;
+};
+
+export type MissionsControllerGetMission0V1Response =
+  MissionsControllerGetMission0V1Responses[keyof MissionsControllerGetMission0V1Responses];
 
-export type MissionsControllerGetMissionData = {
+export type MissionsControllerGetMission1Data = {
   body?: never;
   path: {
     id: string;
@@ -1602,7 +2146,7 @@ export type MissionsControllerGetMissionData = {
   url: "/missions/{id}";
 };
 
-export type MissionsControllerGetMissionErrors = {
+export type MissionsControllerGetMission1Errors = {
   401: unknown;
   403: unknown;
   /**
@@ -1611,14 +2155,14 @@ export type MissionsControllerGetMissionErrors = {
   404: unknown;
 };
 
-export type MissionsControllerGetMissionResponses = {
+export type MissionsControllerGetMission1Responses = {
   200: GetMissionResponseDto;
 };
 
-export type MissionsControllerGetMissionResponse =
-  MissionsControllerGetMissionResponses[keyof MissionsControllerGetMissionResponses];
+export type MissionsControllerGetMission1Response =
+  MissionsControllerGetMission1Responses[keyof MissionsControllerGetMission1Responses];
 
-export type MissionsControllerGetMissionsData = {
+export type MissionsControllerGetMissions0V1Data = {
   body?: never;
   path?: never;
   query?: {
@@ -1636,29 +2180,29 @@ export type MissionsControllerGetMissionsData = {
       | "campaigns"
       | Array<"vault" | "payout" | "campaigns">;
   };
-  url: "/missions";
+  url: "/v1/missions";
 };
 
-export type MissionsControllerGetMissionsErrors = {
+export type MissionsControllerGetMissions0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type MissionsControllerGetMissionsResponses = {
+export type MissionsControllerGetMissions0V1Responses = {
   200: GetMissionsResponseDto;
 };
 
-export type MissionsControllerGetMissionsResponse =
-  MissionsControllerGetMissionsResponses[keyof MissionsControllerGetMissionsResponses];
+export type MissionsControllerGetMissions0V1Response =
+  MissionsControllerGetMissions0V1Responses[keyof MissionsControllerGetMissions0V1Responses];
 
-export type MissionsControllerCreateMissionsData = {
+export type MissionsControllerCreateMissions0V1Data = {
   body: CreateMissionRequestDto;
   path?: never;
   query?: never;
-  url: "/missions";
+  url: "/v1/missions";
 };
 
-export type MissionsControllerCreateMissionsErrors = {
+export type MissionsControllerCreateMissions0V1Errors = {
   /**
    * Validation failed - invalid Zones, mission types, or times
    */
@@ -1674,323 +2218,717 @@ export type MissionsControllerCreateMissionsErrors = {
   500: unknown;
 };
 
-export type MissionsControllerCreateMissionsResponses = {
+export type MissionsControllerCreateMissions0V1Responses = {
   /**
    * Transaction to create mission, queued successfully
    */
   201: CreateMissionResponseDto;
 };
 
-export type MissionsControllerCreateMissionsResponse =
-  MissionsControllerCreateMissionsResponses[keyof MissionsControllerCreateMissionsResponses];
+export type MissionsControllerCreateMissions0V1Response =
+  MissionsControllerCreateMissions0V1Responses[keyof MissionsControllerCreateMissions0V1Responses];
 
-export type MissionsControllerUpdateMissionsData = {
+export type MissionsControllerUpdateMissions0V1Data = {
   body: UpdateMissionsRequestDto;
   path?: never;
   query?: never;
-  url: "/missions";
+  url: "/v1/missions";
 };
 
-export type MissionsControllerUpdateMissionsErrors = {
+export type MissionsControllerUpdateMissions0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type MissionsControllerUpdateMissionsResponses = {
+export type MissionsControllerUpdateMissions0V1Responses = {
   /**
    * Missions update transaction queued successfully
    */
   200: UpdateMissionsResponseDto;
 };
 
-export type MissionsControllerUpdateMissionsResponse =
-  MissionsControllerUpdateMissionsResponses[keyof MissionsControllerUpdateMissionsResponses];
+export type MissionsControllerUpdateMissions0V1Response =
+  MissionsControllerUpdateMissions0V1Responses[keyof MissionsControllerUpdateMissions0V1Responses];
 
-export type MissionsControllerRepriceMissionsData = {
-  body: RepriceMissionsRequestDto;
+export type MissionsControllerGetMissions1Data = {
+  body?: never;
   path?: never;
-  query?: never;
-  url: "/missions/amounts";
-};
-
-export type MissionsControllerRepriceMissionsErrors = {
-  401: unknown;
-  403: unknown;
-};
-
-export type MissionsControllerRepriceMissionsResponses = {
-  /**
+  query?: {
+    updatedAt_gt?: Date;
+    updatedAt_lt?: Date;
+    createdAt_gt?: Date;
+    createdAt_lt?: Date;
+    isOpen?: string;
+    zoneIds?: string | Array<string>;
+    flightPlanId?: number;
+    page?: number;
+    relations?:
+      | "vault"
+      | "payout"
+      | "campaigns"
+      | Array<"vault" | "payout" | "campaigns">;
+  };
+  url: "/missions";
+};
+
+export type MissionsControllerGetMissions1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type MissionsControllerGetMissions1Responses = {
+  200: GetMissionsResponseDto;
+};
+
+export type MissionsControllerGetMissions1Response =
+  MissionsControllerGetMissions1Responses[keyof MissionsControllerGetMissions1Responses];
+
+export type MissionsControllerCreateMissions1Data = {
+  body: CreateMissionRequestDto;
+  path?: never;
+  query?: never;
+  url: "/missions";
+};
+
+export type MissionsControllerCreateMissions1Errors = {
+  /**
+   * Validation failed - invalid Zones, mission types, or times
+   */
+  400: unknown;
+  401: unknown;
+  /**
+   * Insufficient treasury spending limit
+   */
+  403: unknown;
+  /**
+   * Internal server error during mission creation
+   */
+  500: unknown;
+};
+
+export type MissionsControllerCreateMissions1Responses = {
+  /**
+   * Transaction to create mission, queued successfully
+   */
+  201: CreateMissionResponseDto;
+};
+
+export type MissionsControllerCreateMissions1Response =
+  MissionsControllerCreateMissions1Responses[keyof MissionsControllerCreateMissions1Responses];
+
+export type MissionsControllerUpdateMissions1Data = {
+  body: UpdateMissionsRequestDto;
+  path?: never;
+  query?: never;
+  url: "/missions";
+};
+
+export type MissionsControllerUpdateMissions1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type MissionsControllerUpdateMissions1Responses = {
+  /**
+   * Missions update transaction queued successfully
+   */
+  200: UpdateMissionsResponseDto;
+};
+
+export type MissionsControllerUpdateMissions1Response =
+  MissionsControllerUpdateMissions1Responses[keyof MissionsControllerUpdateMissions1Responses];
+
+export type MissionsControllerRepriceMissions0V1Data = {
+  body: RepriceMissionsRequestDto;
+  path?: never;
+  query?: never;
+  url: "/v1/missions/amounts";
+};
+
+export type MissionsControllerRepriceMissions0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type MissionsControllerRepriceMissions0V1Responses = {
+  /**
    * Mission repricing queued successfully
    */
   200: RepriceMissionsResponseDto;
 };
 
-export type MissionsControllerRepriceMissionsResponse =
-  MissionsControllerRepriceMissionsResponses[keyof MissionsControllerRepriceMissionsResponses];
+export type MissionsControllerRepriceMissions0V1Response =
+  MissionsControllerRepriceMissions0V1Responses[keyof MissionsControllerRepriceMissions0V1Responses];
 
-export type ProtocolTriggersApiControllerTriggerPayoutData = {
+export type MissionsControllerRepriceMissions1Data = {
+  body: RepriceMissionsRequestDto;
+  path?: never;
+  query?: never;
+  url: "/missions/amounts";
+};
+
+export type MissionsControllerRepriceMissions1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type MissionsControllerRepriceMissions1Responses = {
+  /**
+   * Mission repricing queued successfully
+   */
+  200: RepriceMissionsResponseDto;
+};
+
+export type MissionsControllerRepriceMissions1Response =
+  MissionsControllerRepriceMissions1Responses[keyof MissionsControllerRepriceMissions1Responses];
+
+export type ProtocolTriggersApiControllerTriggerPayout0V1Data = {
+  body: TriggerPayoutRequestDto;
+  path?: never;
+  query?: never;
+  url: "/v1/protocol-triggers/missions/payout";
+};
+
+export type ProtocolTriggersApiControllerTriggerPayout0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type ProtocolTriggersApiControllerTriggerPayout0V1Responses = {
+  201: unknown;
+};
+
+export type ProtocolTriggersApiControllerTriggerPayout1Data = {
   body: TriggerPayoutRequestDto;
   path?: never;
   query?: never;
   url: "/protocol-triggers/missions/payout";
 };
 
-export type ProtocolTriggersApiControllerTriggerPayoutErrors = {
+export type ProtocolTriggersApiControllerTriggerPayout1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type ProtocolTriggersApiControllerTriggerPayout1Responses = {
+  201: unknown;
+};
+
+export type ProtocolTriggersApiControllerTriggerMissionClose0V1Data = {
+  body: TriggerMissionCloseRequestDto;
+  path?: never;
+  query?: never;
+  url: "/v1/protocol-triggers/missions/close";
+};
+
+export type ProtocolTriggersApiControllerTriggerMissionClose0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type ProtocolTriggersApiControllerTriggerPayoutResponses = {
+export type ProtocolTriggersApiControllerTriggerMissionClose0V1Responses = {
   201: unknown;
 };
 
-export type ProtocolTriggersApiControllerTriggerMissionCloseData = {
+export type ProtocolTriggersApiControllerTriggerMissionClose1Data = {
   body: TriggerMissionCloseRequestDto;
   path?: never;
   query?: never;
   url: "/protocol-triggers/missions/close";
 };
 
-export type ProtocolTriggersApiControllerTriggerMissionCloseErrors = {
+export type ProtocolTriggersApiControllerTriggerMissionClose1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type ProtocolTriggersApiControllerTriggerMissionClose1Responses = {
+  201: unknown;
+};
+
+export type QuotesControllerCreateQuote0V1Data = {
+  body: CreateQuoteRequestDto;
+  path?: never;
+  query?: never;
+  url: "/v1/quotes";
+};
+
+export type QuotesControllerCreateQuote0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type ProtocolTriggersApiControllerTriggerMissionCloseResponses = {
+export type QuotesControllerCreateQuote0V1Responses = {
   201: unknown;
 };
 
-export type QuotesControllerCreateQuoteData = {
+export type QuotesControllerCreateQuote1Data = {
   body: CreateQuoteRequestDto;
   path?: never;
   query?: never;
-  url: "/quotes";
+  url: "/quotes";
+};
+
+export type QuotesControllerCreateQuote1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type QuotesControllerCreateQuote1Responses = {
+  201: unknown;
+};
+
+export type QuotesControllerGetQuote0V1Data = {
+  body?: never;
+  path: {
+    id: string;
+  };
+  query?: never;
+  url: "/v1/quotes/{id}";
+};
+
+export type QuotesControllerGetQuote0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type QuotesControllerGetQuote0V1Responses = {
+  200: unknown;
+};
+
+export type QuotesControllerGetQuote1Data = {
+  body?: never;
+  path: {
+    id: string;
+  };
+  query?: never;
+  url: "/quotes/{id}";
+};
+
+export type QuotesControllerGetQuote1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type QuotesControllerGetQuote1Responses = {
+  200: unknown;
+};
+
+export type SchemaControllerGetEventSchema0V1Data = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: "/v1/schema/event";
+};
+
+export type SchemaControllerGetEventSchema0V1Responses = {
+  /**
+   * Get event schema
+   */
+  200: unknown;
+};
+
+export type SchemaControllerGetEventSchema1Data = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: "/schema/event";
+};
+
+export type SchemaControllerGetEventSchema1Responses = {
+  /**
+   * Get event schema
+   */
+  200: unknown;
+};
+
+export type VaultsControllerCreateVaults0V1Data = {
+  body: CreateVaultsRequestDto;
+  path?: never;
+  query?: never;
+  url: "/v1/vaults";
+};
+
+export type VaultsControllerCreateVaults0V1Errors = {
+  /**
+   * Validation failed - invalid funder, amount, or contract address
+   */
+  400: unknown;
+  401: unknown;
+  403: unknown;
+  /**
+   * Internal server error during vault request creation
+   */
+  500: unknown;
+};
+
+export type VaultsControllerCreateVaults0V1Responses = {
+  /**
+   * Vault requests posted successfully
+   */
+  201: CreateVaultsResponseDto;
+};
+
+export type VaultsControllerCreateVaults0V1Response =
+  VaultsControllerCreateVaults0V1Responses[keyof VaultsControllerCreateVaults0V1Responses];
+
+export type VaultsControllerCreateVaults1Data = {
+  body: CreateVaultsRequestDto;
+  path?: never;
+  query?: never;
+  url: "/vaults";
+};
+
+export type VaultsControllerCreateVaults1Errors = {
+  /**
+   * Validation failed - invalid funder, amount, or contract address
+   */
+  400: unknown;
+  401: unknown;
+  403: unknown;
+  /**
+   * Internal server error during vault request creation
+   */
+  500: unknown;
+};
+
+export type VaultsControllerCreateVaults1Responses = {
+  /**
+   * Vault requests posted successfully
+   */
+  201: CreateVaultsResponseDto;
+};
+
+export type VaultsControllerCreateVaults1Response =
+  VaultsControllerCreateVaults1Responses[keyof VaultsControllerCreateVaults1Responses];
+
+export type WebhooksControllerGetMany0V1Data = {
+  body?: never;
+  path: {
+    org_id: number;
+  };
+  query?: never;
+  url: "/v1/org/{org_id}/webhooks";
+};
+
+export type WebhooksControllerGetMany0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type WebhooksControllerGetMany0V1Responses = {
+  200: GetWebhooksResponse;
+};
+
+export type WebhooksControllerGetMany0V1Response =
+  WebhooksControllerGetMany0V1Responses[keyof WebhooksControllerGetMany0V1Responses];
+
+export type WebhooksControllerCreate0V1Data = {
+  body: CreateWebhookBody;
+  path: {
+    org_id: number;
+  };
+  query?: never;
+  url: "/v1/org/{org_id}/webhooks";
+};
+
+export type WebhooksControllerCreate0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type WebhooksControllerCreate0V1Responses = {
+  201: CreateWebhookResponse;
+};
+
+export type WebhooksControllerCreate0V1Response =
+  WebhooksControllerCreate0V1Responses[keyof WebhooksControllerCreate0V1Responses];
+
+export type WebhooksControllerGetMany1Data = {
+  body?: never;
+  path: {
+    org_id: number;
+  };
+  query?: never;
+  url: "/org/{org_id}/webhooks";
+};
+
+export type WebhooksControllerGetMany1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type WebhooksControllerGetMany1Responses = {
+  200: GetWebhooksResponse;
+};
+
+export type WebhooksControllerGetMany1Response =
+  WebhooksControllerGetMany1Responses[keyof WebhooksControllerGetMany1Responses];
+
+export type WebhooksControllerCreate1Data = {
+  body: CreateWebhookBody;
+  path: {
+    org_id: number;
+  };
+  query?: never;
+  url: "/org/{org_id}/webhooks";
+};
+
+export type WebhooksControllerCreate1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type WebhooksControllerCreate1Responses = {
+  201: CreateWebhookResponse;
+};
+
+export type WebhooksControllerCreate1Response =
+  WebhooksControllerCreate1Responses[keyof WebhooksControllerCreate1Responses];
+
+export type WebhooksControllerDelete0V1Data = {
+  body?: never;
+  path: {
+    org_id: number;
+    id: number;
+  };
+  query?: never;
+  url: "/v1/org/{org_id}/webhooks/{id}";
+};
+
+export type WebhooksControllerDelete0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type WebhooksControllerDelete0V1Responses = {
+  200: DeleteWebhookResponse;
+};
+
+export type WebhooksControllerDelete0V1Response =
+  WebhooksControllerDelete0V1Responses[keyof WebhooksControllerDelete0V1Responses];
+
+export type WebhooksControllerGet0V1Data = {
+  body?: never;
+  path: {
+    org_id: number;
+    id: number;
+  };
+  query?: never;
+  url: "/v1/org/{org_id}/webhooks/{id}";
 };
 
-export type QuotesControllerCreateQuoteErrors = {
+export type WebhooksControllerGet0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type QuotesControllerCreateQuoteResponses = {
-  201: unknown;
+export type WebhooksControllerGet0V1Responses = {
+  200: GetWebhookResponse;
 };
 
-export type QuotesControllerGetQuoteData = {
-  body?: never;
+export type WebhooksControllerGet0V1Response =
+  WebhooksControllerGet0V1Responses[keyof WebhooksControllerGet0V1Responses];
+
+export type WebhooksControllerUpdate0V1Data = {
+  body: UpdateWebhookBody;
   path: {
-    id: string;
+    org_id: number;
+    id: number;
   };
   query?: never;
-  url: "/quotes/{id}";
+  url: "/v1/org/{org_id}/webhooks/{id}";
 };
 
-export type QuotesControllerGetQuoteErrors = {
+export type WebhooksControllerUpdate0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type QuotesControllerGetQuoteResponses = {
-  200: unknown;
-};
-
-export type SchemaControllerGetEventSchemaData = {
-  body?: never;
-  path?: never;
-  query?: never;
-  url: "/schema/event";
+export type WebhooksControllerUpdate0V1Responses = {
+  200: UpdateWebhookResponse;
 };
 
-export type SchemaControllerGetEventSchemaResponses = {
-  /**
-   * Get event schema
-   */
-  200: unknown;
-};
+export type WebhooksControllerUpdate0V1Response =
+  WebhooksControllerUpdate0V1Responses[keyof WebhooksControllerUpdate0V1Responses];
 
-export type VaultsControllerCreateVaultsData = {
-  body: CreateVaultsRequestDto;
-  path?: never;
+export type WebhooksControllerDelete1Data = {
+  body?: never;
+  path: {
+    org_id: number;
+    id: number;
+  };
   query?: never;
-  url: "/vaults";
+  url: "/org/{org_id}/webhooks/{id}";
 };
 
-export type VaultsControllerCreateVaultsErrors = {
-  /**
-   * Validation failed - invalid funder, amount, or contract address
-   */
-  400: unknown;
+export type WebhooksControllerDelete1Errors = {
   401: unknown;
   403: unknown;
-  /**
-   * Internal server error during vault request creation
-   */
-  500: unknown;
 };
 
-export type VaultsControllerCreateVaultsResponses = {
-  /**
-   * Vault requests posted successfully
-   */
-  201: CreateVaultsResponseDto;
+export type WebhooksControllerDelete1Responses = {
+  200: DeleteWebhookResponse;
 };
 
-export type VaultsControllerCreateVaultsResponse =
-  VaultsControllerCreateVaultsResponses[keyof VaultsControllerCreateVaultsResponses];
+export type WebhooksControllerDelete1Response =
+  WebhooksControllerDelete1Responses[keyof WebhooksControllerDelete1Responses];
 
-export type WebhooksControllerGetManyData = {
+export type WebhooksControllerGet1Data = {
   body?: never;
   path: {
     org_id: number;
+    id: number;
   };
   query?: never;
-  url: "/org/{org_id}/webhooks";
+  url: "/org/{org_id}/webhooks/{id}";
 };
 
-export type WebhooksControllerGetManyErrors = {
+export type WebhooksControllerGet1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type WebhooksControllerGetManyResponses = {
-  200: GetWebhooksResponse;
+export type WebhooksControllerGet1Responses = {
+  200: GetWebhookResponse;
 };
 
-export type WebhooksControllerGetManyResponse =
-  WebhooksControllerGetManyResponses[keyof WebhooksControllerGetManyResponses];
+export type WebhooksControllerGet1Response =
+  WebhooksControllerGet1Responses[keyof WebhooksControllerGet1Responses];
 
-export type WebhooksControllerCreateData = {
-  body: CreateWebhookBody;
+export type WebhooksControllerUpdate1Data = {
+  body: UpdateWebhookBody;
   path: {
     org_id: number;
+    id: number;
   };
   query?: never;
-  url: "/org/{org_id}/webhooks";
+  url: "/org/{org_id}/webhooks/{id}";
 };
 
-export type WebhooksControllerCreateErrors = {
+export type WebhooksControllerUpdate1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type WebhooksControllerCreateResponses = {
-  201: CreateWebhookResponse;
+export type WebhooksControllerUpdate1Responses = {
+  200: UpdateWebhookResponse;
 };
 
-export type WebhooksControllerCreateResponse =
-  WebhooksControllerCreateResponses[keyof WebhooksControllerCreateResponses];
+export type WebhooksControllerUpdate1Response =
+  WebhooksControllerUpdate1Responses[keyof WebhooksControllerUpdate1Responses];
 
-export type WebhooksControllerDeleteData = {
-  body?: never;
+export type WebhooksControllerRegenerateSecret0V1Data = {
+  body: RegenerateWebhookSecretBody;
   path: {
     org_id: number;
     id: number;
   };
   query?: never;
-  url: "/org/{org_id}/webhooks/{id}";
+  url: "/v1/org/{org_id}/webhooks/{id}/regenerate-secret";
 };
 
-export type WebhooksControllerDeleteErrors = {
+export type WebhooksControllerRegenerateSecret0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type WebhooksControllerDeleteResponses = {
-  200: DeleteWebhookResponse;
+export type WebhooksControllerRegenerateSecret0V1Responses = {
+  200: RegenerateWebhookSecretResponseDto;
 };
 
-export type WebhooksControllerDeleteResponse =
-  WebhooksControllerDeleteResponses[keyof WebhooksControllerDeleteResponses];
+export type WebhooksControllerRegenerateSecret0V1Response =
+  WebhooksControllerRegenerateSecret0V1Responses[keyof WebhooksControllerRegenerateSecret0V1Responses];
 
-export type WebhooksControllerGetData = {
-  body?: never;
+export type WebhooksControllerRegenerateSecret1Data = {
+  body: RegenerateWebhookSecretBody;
   path: {
     org_id: number;
     id: number;
   };
   query?: never;
-  url: "/org/{org_id}/webhooks/{id}";
+  url: "/org/{org_id}/webhooks/{id}/regenerate-secret";
 };
 
-export type WebhooksControllerGetErrors = {
+export type WebhooksControllerRegenerateSecret1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type WebhooksControllerGetResponses = {
-  200: GetWebhookResponse;
+export type WebhooksControllerRegenerateSecret1Responses = {
+  200: RegenerateWebhookSecretResponseDto;
 };
 
-export type WebhooksControllerGetResponse =
-  WebhooksControllerGetResponses[keyof WebhooksControllerGetResponses];
+export type WebhooksControllerRegenerateSecret1Response =
+  WebhooksControllerRegenerateSecret1Responses[keyof WebhooksControllerRegenerateSecret1Responses];
 
-export type WebhooksControllerUpdateData = {
-  body: UpdateWebhookBody;
+export type WebhooksControllerTest0V1Data = {
+  body?: never;
   path: {
     org_id: number;
     id: number;
   };
   query?: never;
-  url: "/org/{org_id}/webhooks/{id}";
+  url: "/v1/org/{org_id}/webhooks/{id}/test";
 };
 
-export type WebhooksControllerUpdateErrors = {
+export type WebhooksControllerTest0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type WebhooksControllerUpdateResponses = {
-  200: UpdateWebhookResponse;
+export type WebhooksControllerTest0V1Responses = {
+  200: TestWebhookResponse;
 };
 
-export type WebhooksControllerUpdateResponse =
-  WebhooksControllerUpdateResponses[keyof WebhooksControllerUpdateResponses];
+export type WebhooksControllerTest0V1Response =
+  WebhooksControllerTest0V1Responses[keyof WebhooksControllerTest0V1Responses];
 
-export type WebhooksControllerRegenerateSecretData = {
-  body: RegenerateWebhookSecretBody;
+export type WebhooksControllerTest1Data = {
+  body?: never;
   path: {
     org_id: number;
     id: number;
   };
   query?: never;
-  url: "/org/{org_id}/webhooks/{id}/regenerate-secret";
+  url: "/org/{org_id}/webhooks/{id}/test";
 };
 
-export type WebhooksControllerRegenerateSecretErrors = {
+export type WebhooksControllerTest1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type WebhooksControllerRegenerateSecretResponses = {
-  200: RegenerateWebhookSecretResponseDto;
+export type WebhooksControllerTest1Responses = {
+  200: TestWebhookResponse;
 };
 
-export type WebhooksControllerRegenerateSecretResponse =
-  WebhooksControllerRegenerateSecretResponses[keyof WebhooksControllerRegenerateSecretResponses];
+export type WebhooksControllerTest1Response =
+  WebhooksControllerTest1Responses[keyof WebhooksControllerTest1Responses];
 
-export type WebhooksControllerTestData = {
+export type WebhooksControllerGetStatus0V1Data = {
   body?: never;
   path: {
     org_id: number;
     id: number;
   };
   query?: never;
-  url: "/org/{org_id}/webhooks/{id}/test";
+  url: "/v1/org/{org_id}/webhooks/{id}/status";
 };
 
-export type WebhooksControllerTestErrors = {
+export type WebhooksControllerGetStatus0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type WebhooksControllerTestResponses = {
-  200: TestWebhookResponse;
+export type WebhooksControllerGetStatus0V1Responses = {
+  200: GetWebhookStatusResponse;
 };
 
-export type WebhooksControllerTestResponse =
-  WebhooksControllerTestResponses[keyof WebhooksControllerTestResponses];
+export type WebhooksControllerGetStatus0V1Response =
+  WebhooksControllerGetStatus0V1Responses[keyof WebhooksControllerGetStatus0V1Responses];
 
-export type WebhooksControllerGetStatusData = {
+export type WebhooksControllerGetStatus1Data = {
   body?: never;
   path: {
     org_id: number;
@@ -2000,26 +2938,53 @@ export type WebhooksControllerGetStatusData = {
   url: "/org/{org_id}/webhooks/{id}/status";
 };
 
-export type WebhooksControllerGetStatusErrors = {
+export type WebhooksControllerGetStatus1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type WebhooksControllerGetStatusResponses = {
+export type WebhooksControllerGetStatus1Responses = {
   200: GetWebhookStatusResponse;
 };
 
-export type WebhooksControllerGetStatusResponse =
-  WebhooksControllerGetStatusResponses[keyof WebhooksControllerGetStatusResponses];
+export type WebhooksControllerGetStatus1Response =
+  WebhooksControllerGetStatus1Responses[keyof WebhooksControllerGetStatus1Responses];
+
+export type ZonesControllerCreateZone0V1Data = {
+  body: CreateZoneDto;
+  path?: never;
+  query?: never;
+  url: "/v1/zones";
+};
+
+export type ZonesControllerCreateZone0V1Errors = {
+  /**
+   * Invalid zone id (must be a valid level-9 H3 cell)
+   */
+  400: unknown;
+  401: unknown;
+  403: unknown;
+  /**
+   * Zone already exists
+   */
+  409: unknown;
+};
+
+export type ZonesControllerCreateZone0V1Responses = {
+  201: ZoneResponseDto;
+};
 
-export type ZonesControllerCreateZoneData = {
+export type ZonesControllerCreateZone0V1Response =
+  ZonesControllerCreateZone0V1Responses[keyof ZonesControllerCreateZone0V1Responses];
+
+export type ZonesControllerCreateZone1Data = {
   body: CreateZoneDto;
   path?: never;
   query?: never;
   url: "/zones";
 };
 
-export type ZonesControllerCreateZoneErrors = {
+export type ZonesControllerCreateZone1Errors = {
   /**
    * Invalid zone id (must be a valid level-9 H3 cell)
    */
@@ -2032,14 +2997,67 @@ export type ZonesControllerCreateZoneErrors = {
   409: unknown;
 };
 
-export type ZonesControllerCreateZoneResponses = {
+export type ZonesControllerCreateZone1Responses = {
   201: ZoneResponseDto;
 };
 
-export type ZonesControllerCreateZoneResponse =
-  ZonesControllerCreateZoneResponses[keyof ZonesControllerCreateZoneResponses];
+export type ZonesControllerCreateZone1Response =
+  ZonesControllerCreateZone1Responses[keyof ZonesControllerCreateZone1Responses];
+
+export type ZonesControllerDeleteZone0V1Data = {
+  body?: never;
+  path: {
+    id: string;
+  };
+  query?: never;
+  url: "/v1/zones/{id}";
+};
+
+export type ZonesControllerDeleteZone0V1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Zone not found
+   */
+  404: unknown;
+};
+
+export type ZonesControllerDeleteZone0V1Responses = {
+  /**
+   * Zone deleted
+   */
+  204: void;
+};
+
+export type ZonesControllerDeleteZone0V1Response =
+  ZonesControllerDeleteZone0V1Responses[keyof ZonesControllerDeleteZone0V1Responses];
+
+export type ZonesControllerUpdateZone0V1Data = {
+  body: UpdateZoneDto;
+  path: {
+    id: string;
+  };
+  query?: never;
+  url: "/v1/zones/{id}";
+};
+
+export type ZonesControllerUpdateZone0V1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Zone not found
+   */
+  404: unknown;
+};
+
+export type ZonesControllerUpdateZone0V1Responses = {
+  200: ZoneResponseDto;
+};
+
+export type ZonesControllerUpdateZone0V1Response =
+  ZonesControllerUpdateZone0V1Responses[keyof ZonesControllerUpdateZone0V1Responses];
 
-export type ZonesControllerDeleteZoneData = {
+export type ZonesControllerDeleteZone1Data = {
   body?: never;
   path: {
     id: string;
@@ -2048,7 +3066,7 @@ export type ZonesControllerDeleteZoneData = {
   url: "/zones/{id}";
 };
 
-export type ZonesControllerDeleteZoneErrors = {
+export type ZonesControllerDeleteZone1Errors = {
   401: unknown;
   403: unknown;
   /**
@@ -2057,17 +3075,17 @@ export type ZonesControllerDeleteZoneErrors = {
   404: unknown;
 };
 
-export type ZonesControllerDeleteZoneResponses = {
+export type ZonesControllerDeleteZone1Responses = {
   /**
    * Zone deleted
    */
   204: void;
 };
 
-export type ZonesControllerDeleteZoneResponse =
-  ZonesControllerDeleteZoneResponses[keyof ZonesControllerDeleteZoneResponses];
+export type ZonesControllerDeleteZone1Response =
+  ZonesControllerDeleteZone1Responses[keyof ZonesControllerDeleteZone1Responses];
 
-export type ZonesControllerUpdateZoneData = {
+export type ZonesControllerUpdateZone1Data = {
   body: UpdateZoneDto;
   path: {
     id: string;
@@ -2076,7 +3094,7 @@ export type ZonesControllerUpdateZoneData = {
   url: "/zones/{id}";
 };
 
-export type ZonesControllerUpdateZoneErrors = {
+export type ZonesControllerUpdateZone1Errors = {
   401: unknown;
   403: unknown;
   /**
@@ -2085,49 +3103,97 @@ export type ZonesControllerUpdateZoneErrors = {
   404: unknown;
 };
 
-export type ZonesControllerUpdateZoneResponses = {
+export type ZonesControllerUpdateZone1Responses = {
   200: ZoneResponseDto;
 };
 
-export type ZonesControllerUpdateZoneResponse =
-  ZonesControllerUpdateZoneResponses[keyof ZonesControllerUpdateZoneResponses];
+export type ZonesControllerUpdateZone1Response =
+  ZonesControllerUpdateZone1Responses[keyof ZonesControllerUpdateZone1Responses];
 
-export type EventProcessorMissionsSyncControllerResyncMissionsData = {
+export type EventProcessorMissionsSyncControllerResyncMissions0V1Data = {
   body: SyncEventProcessorMissionsRequestDto;
   path?: never;
   query?: never;
-  url: "/event-processor/missions/sync";
+  url: "/v1/event-processor/missions/sync";
 };
 
-export type EventProcessorMissionsSyncControllerResyncMissionsErrors = {
+export type EventProcessorMissionsSyncControllerResyncMissions0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type EventProcessorMissionsSyncControllerResyncMissionsResponses = {
+export type EventProcessorMissionsSyncControllerResyncMissions0V1Responses = {
   /**
    * Per-mission success or failure.
    */
   200: SyncEventProcessorMissionsResponseDto;
 };
 
-export type EventProcessorMissionsSyncControllerResyncMissionsResponse =
-  EventProcessorMissionsSyncControllerResyncMissionsResponses[keyof EventProcessorMissionsSyncControllerResyncMissionsResponses];
+export type EventProcessorMissionsSyncControllerResyncMissions0V1Response =
+  EventProcessorMissionsSyncControllerResyncMissions0V1Responses[keyof EventProcessorMissionsSyncControllerResyncMissions0V1Responses];
 
-export type EventProcessorFlightReviewsSyncControllerResyncFlightReviewsData = {
-  body: SyncEventProcessorFlightReviewsRequestDto;
+export type EventProcessorMissionsSyncControllerResyncMissions1Data = {
+  body: SyncEventProcessorMissionsRequestDto;
   path?: never;
   query?: never;
-  url: "/event-processor/flightreviews";
+  url: "/event-processor/missions/sync";
+};
+
+export type EventProcessorMissionsSyncControllerResyncMissions1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type EventProcessorMissionsSyncControllerResyncMissions1Responses = {
+  /**
+   * Per-mission success or failure.
+   */
+  200: SyncEventProcessorMissionsResponseDto;
 };
 
-export type EventProcessorFlightReviewsSyncControllerResyncFlightReviewsErrors =
+export type EventProcessorMissionsSyncControllerResyncMissions1Response =
+  EventProcessorMissionsSyncControllerResyncMissions1Responses[keyof EventProcessorMissionsSyncControllerResyncMissions1Responses];
+
+export type EventProcessorFlightReviewsSyncControllerResyncFlightReviews0V1Data =
+  {
+    body: SyncEventProcessorFlightReviewsRequestDto;
+    path?: never;
+    query?: never;
+    url: "/v1/event-processor/flightreviews";
+  };
+
+export type EventProcessorFlightReviewsSyncControllerResyncFlightReviews0V1Errors =
+  {
+    401: unknown;
+    403: unknown;
+  };
+
+export type EventProcessorFlightReviewsSyncControllerResyncFlightReviews0V1Responses =
+  {
+    /**
+     * Per-flight success or failure.
+     */
+    200: SyncEventProcessorFlightReviewsResponseDto;
+  };
+
+export type EventProcessorFlightReviewsSyncControllerResyncFlightReviews0V1Response =
+  EventProcessorFlightReviewsSyncControllerResyncFlightReviews0V1Responses[keyof EventProcessorFlightReviewsSyncControllerResyncFlightReviews0V1Responses];
+
+export type EventProcessorFlightReviewsSyncControllerResyncFlightReviews1Data =
+  {
+    body: SyncEventProcessorFlightReviewsRequestDto;
+    path?: never;
+    query?: never;
+    url: "/event-processor/flightreviews";
+  };
+
+export type EventProcessorFlightReviewsSyncControllerResyncFlightReviews1Errors =
   {
     401: unknown;
     403: unknown;
   };
 
-export type EventProcessorFlightReviewsSyncControllerResyncFlightReviewsResponses =
+export type EventProcessorFlightReviewsSyncControllerResyncFlightReviews1Responses =
   {
     /**
      * Per-flight success or failure.
@@ -2135,59 +3201,171 @@ export type EventProcessorFlightReviewsSyncControllerResyncFlightReviewsResponse
     200: SyncEventProcessorFlightReviewsResponseDto;
   };
 
-export type EventProcessorFlightReviewsSyncControllerResyncFlightReviewsResponse =
-  EventProcessorFlightReviewsSyncControllerResyncFlightReviewsResponses[keyof EventProcessorFlightReviewsSyncControllerResyncFlightReviewsResponses];
+export type EventProcessorFlightReviewsSyncControllerResyncFlightReviews1Response =
+  EventProcessorFlightReviewsSyncControllerResyncFlightReviews1Responses[keyof EventProcessorFlightReviewsSyncControllerResyncFlightReviews1Responses];
+
+export type AlchemyControllerHandleWebhook0V1Data = {
+  body: AlchemyWebhookBodyDto;
+  path?: never;
+  query?: never;
+  url: "/v1/webhooks/inbound/alchemy";
+};
+
+export type AlchemyControllerHandleWebhook0V1Responses = {
+  200: unknown;
+};
 
-export type AlchemyControllerHandleWebhookData = {
+export type AlchemyControllerHandleWebhook1Data = {
   body: AlchemyWebhookBodyDto;
   path?: never;
   query?: never;
   url: "/webhooks/inbound/alchemy";
 };
 
-export type AlchemyControllerHandleWebhookResponses = {
+export type AlchemyControllerHandleWebhook1Responses = {
   200: unknown;
 };
 
-export type InboundWebhookConfigsControllerGetManyData = {
+export type InboundWebhookConfigsControllerGetMany0V1Data = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: "/v1/webhooks/inbound/configs";
+};
+
+export type InboundWebhookConfigsControllerGetMany0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type InboundWebhookConfigsControllerGetMany0V1Responses = {
+  200: GetInboundWebhookConfigsResponse;
+};
+
+export type InboundWebhookConfigsControllerGetMany0V1Response =
+  InboundWebhookConfigsControllerGetMany0V1Responses[keyof InboundWebhookConfigsControllerGetMany0V1Responses];
+
+export type InboundWebhookConfigsControllerCreate0V1Data = {
+  body: CreateInboundWebhookConfigBody;
+  path?: never;
+  query?: never;
+  url: "/v1/webhooks/inbound/configs";
+};
+
+export type InboundWebhookConfigsControllerCreate0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type InboundWebhookConfigsControllerCreate0V1Responses = {
+  201: CreateInboundWebhookConfigResponse;
+};
+
+export type InboundWebhookConfigsControllerCreate0V1Response =
+  InboundWebhookConfigsControllerCreate0V1Responses[keyof InboundWebhookConfigsControllerCreate0V1Responses];
+
+export type InboundWebhookConfigsControllerGetMany1Data = {
   body?: never;
   path?: never;
   query?: never;
   url: "/webhooks/inbound/configs";
 };
 
-export type InboundWebhookConfigsControllerGetManyErrors = {
+export type InboundWebhookConfigsControllerGetMany1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type InboundWebhookConfigsControllerGetManyResponses = {
+export type InboundWebhookConfigsControllerGetMany1Responses = {
   200: GetInboundWebhookConfigsResponse;
 };
 
-export type InboundWebhookConfigsControllerGetManyResponse =
-  InboundWebhookConfigsControllerGetManyResponses[keyof InboundWebhookConfigsControllerGetManyResponses];
+export type InboundWebhookConfigsControllerGetMany1Response =
+  InboundWebhookConfigsControllerGetMany1Responses[keyof InboundWebhookConfigsControllerGetMany1Responses];
 
-export type InboundWebhookConfigsControllerCreateData = {
+export type InboundWebhookConfigsControllerCreate1Data = {
   body: CreateInboundWebhookConfigBody;
   path?: never;
   query?: never;
   url: "/webhooks/inbound/configs";
 };
 
-export type InboundWebhookConfigsControllerCreateErrors = {
+export type InboundWebhookConfigsControllerCreate1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type InboundWebhookConfigsControllerCreateResponses = {
+export type InboundWebhookConfigsControllerCreate1Responses = {
   201: CreateInboundWebhookConfigResponse;
 };
 
-export type InboundWebhookConfigsControllerCreateResponse =
-  InboundWebhookConfigsControllerCreateResponses[keyof InboundWebhookConfigsControllerCreateResponses];
+export type InboundWebhookConfigsControllerCreate1Response =
+  InboundWebhookConfigsControllerCreate1Responses[keyof InboundWebhookConfigsControllerCreate1Responses];
+
+export type InboundWebhookConfigsControllerDelete0V1Data = {
+  body?: never;
+  path: {
+    id: number;
+  };
+  query?: never;
+  url: "/v1/webhooks/inbound/configs/{id}";
+};
+
+export type InboundWebhookConfigsControllerDelete0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type InboundWebhookConfigsControllerDelete0V1Responses = {
+  200: DeleteInboundWebhookConfigResponse;
+};
+
+export type InboundWebhookConfigsControllerDelete0V1Response =
+  InboundWebhookConfigsControllerDelete0V1Responses[keyof InboundWebhookConfigsControllerDelete0V1Responses];
+
+export type InboundWebhookConfigsControllerGet0V1Data = {
+  body?: never;
+  path: {
+    id: number;
+  };
+  query?: never;
+  url: "/v1/webhooks/inbound/configs/{id}";
+};
+
+export type InboundWebhookConfigsControllerGet0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type InboundWebhookConfigsControllerGet0V1Responses = {
+  200: GetInboundWebhookConfigResponse;
+};
+
+export type InboundWebhookConfigsControllerGet0V1Response =
+  InboundWebhookConfigsControllerGet0V1Responses[keyof InboundWebhookConfigsControllerGet0V1Responses];
+
+export type InboundWebhookConfigsControllerUpdate0V1Data = {
+  body: UpdateInboundWebhookConfigBody;
+  path: {
+    id: number;
+  };
+  query?: never;
+  url: "/v1/webhooks/inbound/configs/{id}";
+};
+
+export type InboundWebhookConfigsControllerUpdate0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type InboundWebhookConfigsControllerUpdate0V1Responses = {
+  200: UpdateInboundWebhookConfigResponse;
+};
+
+export type InboundWebhookConfigsControllerUpdate0V1Response =
+  InboundWebhookConfigsControllerUpdate0V1Responses[keyof InboundWebhookConfigsControllerUpdate0V1Responses];
 
-export type InboundWebhookConfigsControllerDeleteData = {
+export type InboundWebhookConfigsControllerDelete1Data = {
   body?: never;
   path: {
     id: number;
@@ -2196,19 +3374,19 @@ export type InboundWebhookConfigsControllerDeleteData = {
   url: "/webhooks/inbound/configs/{id}";
 };
 
-export type InboundWebhookConfigsControllerDeleteErrors = {
+export type InboundWebhookConfigsControllerDelete1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type InboundWebhookConfigsControllerDeleteResponses = {
+export type InboundWebhookConfigsControllerDelete1Responses = {
   200: DeleteInboundWebhookConfigResponse;
 };
 
-export type InboundWebhookConfigsControllerDeleteResponse =
-  InboundWebhookConfigsControllerDeleteResponses[keyof InboundWebhookConfigsControllerDeleteResponses];
+export type InboundWebhookConfigsControllerDelete1Response =
+  InboundWebhookConfigsControllerDelete1Responses[keyof InboundWebhookConfigsControllerDelete1Responses];
 
-export type InboundWebhookConfigsControllerGetData = {
+export type InboundWebhookConfigsControllerGet1Data = {
   body?: never;
   path: {
     id: number;
@@ -2217,19 +3395,19 @@ export type InboundWebhookConfigsControllerGetData = {
   url: "/webhooks/inbound/configs/{id}";
 };
 
-export type InboundWebhookConfigsControllerGetErrors = {
+export type InboundWebhookConfigsControllerGet1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type InboundWebhookConfigsControllerGetResponses = {
+export type InboundWebhookConfigsControllerGet1Responses = {
   200: GetInboundWebhookConfigResponse;
 };
 
-export type InboundWebhookConfigsControllerGetResponse =
-  InboundWebhookConfigsControllerGetResponses[keyof InboundWebhookConfigsControllerGetResponses];
+export type InboundWebhookConfigsControllerGet1Response =
+  InboundWebhookConfigsControllerGet1Responses[keyof InboundWebhookConfigsControllerGet1Responses];
 
-export type InboundWebhookConfigsControllerUpdateData = {
+export type InboundWebhookConfigsControllerUpdate1Data = {
   body: UpdateInboundWebhookConfigBody;
   path: {
     id: number;
@@ -2238,17 +3416,17 @@ export type InboundWebhookConfigsControllerUpdateData = {
   url: "/webhooks/inbound/configs/{id}";
 };
 
-export type InboundWebhookConfigsControllerUpdateErrors = {
+export type InboundWebhookConfigsControllerUpdate1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type InboundWebhookConfigsControllerUpdateResponses = {
+export type InboundWebhookConfigsControllerUpdate1Responses = {
   200: UpdateInboundWebhookConfigResponse;
 };
 
-export type InboundWebhookConfigsControllerUpdateResponse =
-  InboundWebhookConfigsControllerUpdateResponses[keyof InboundWebhookConfigsControllerUpdateResponses];
+export type InboundWebhookConfigsControllerUpdate1Response =
+  InboundWebhookConfigsControllerUpdate1Responses[keyof InboundWebhookConfigsControllerUpdate1Responses];
 
 export type ClientOptions = {
   baseUrl: string;