@layer-drone/protocol 0.8.0 → 1.0.1

package/src/client/types.gen.ts

@@ -22,6 +22,7 @@ export type CreateApiTokenResponseDto = {
     | "manageProposals"
     | "approveProposals"
     | "manageProtocolTriggers"
+    | "manageCampaigns"
     | "all"
   >;
 };
@@ -44,6 +45,7 @@ export type CreateApiTokenRequestDto = {
     | "manageProposals"
     | "approveProposals"
     | "manageProtocolTriggers"
+    | "manageCampaigns"
     | "all"
   >;
   orgId: number;
@@ -67,6 +69,7 @@ export type UpdateApiTokenRequestDto = {
     | "manageProposals"
     | "approveProposals"
     | "manageProtocolTriggers"
+    | "manageCampaigns"
     | "all"
   >;
 };
@@ -93,10 +96,52 @@ export type UpdateApiTokenResponseDto = {
     | "manageProposals"
     | "approveProposals"
     | "manageProtocolTriggers"
+    | "manageCampaigns"
     | "all"
   >;
 };
 
+export type CreateCampaignBody = {
+  id: string;
+  name: string;
+};
+
+export type CreateCampaignResponse = {
+  id: string;
+  name: string;
+  created_at: string;
+  updated_at: string;
+};
+
+export type GetCampaignsResponse = Array<{
+  id: string;
+  name: string;
+  created_at: string;
+  updated_at: string;
+}>;
+
+export type GetCampaignResponse = {
+  id: string;
+  name: string;
+  created_at: string;
+  updated_at: string;
+};
+
+export type UpdateCampaignBody = {
+  name: string;
+};
+
+export type UpdateCampaignResponse = {
+  id: string;
+  name: string;
+  created_at: string;
+  updated_at: string;
+};
+
+export type DeleteCampaignResponse = {
+  message: string;
+};
+
 export type GetTimeLimitsForSunAltitudeResponse = {
   OptimalSunAltitudePeriod: {
     StartTime: Date;
@@ -724,6 +769,7 @@ export type UpdateMissionsRequestDto = {
     isOpen?: boolean;
     collateralToken?: string;
     decimals?: number;
+    campaigns?: Array<string>;
   }>;
   treasuryAddress: string;
 };
@@ -734,6 +780,7 @@ export type UpdateMissionsResponseDto = {
     escrowRequestsQueued: Array<string>;
     withdrawalRequestsQueued: Array<string>;
     cancelRequestsQueued: Array<string>;
+    campaignsUpdated: Array<string>;
   };
 };
 
@@ -755,6 +802,159 @@ export type RepriceMissionsResponseDto = {
   };
 };
 
+export type CreateProposalRequestDto = {
+  name: string;
+  created_by: string;
+  description?: string;
+  source?: {
+    tool: "arcgis-plugin";
+    version?: string;
+  };
+  changes: Array<
+    | {
+        payload: {
+          id: string;
+          region_id: number;
+          is_flyable?: boolean;
+        };
+        action: "zone.create";
+      }
+    | {
+        resource_id: string;
+        payload: {
+          is_flyable: boolean;
+        };
+        action: "zone.update";
+      }
+    | {
+        resource_id: string;
+        action: "zone.delete";
+      }
+    | {
+        payload: {
+          id: string;
+          name: string;
+        };
+        action: "campaign.create";
+      }
+    | {
+        resource_id: string;
+        payload: {
+          name?: string;
+        };
+        action: "campaign.update";
+      }
+    | {
+        resource_id: string;
+        action: "campaign.delete";
+      }
+    | {
+        payload: {
+          requestor: string;
+          zone_id: string;
+          campaigns: Array<string>;
+          flight_plan_id: number;
+          amount: string | number | bigint;
+          collateral_token: string;
+          decimals: number;
+          capture_start_time: Date;
+          capture_end_time: Date;
+          is_reservable?: boolean;
+          tags?: {
+            [key: string]: string;
+          };
+        };
+        action: "mission.create";
+      }
+    | {
+        resource_id: string;
+        payload: {
+          amount?: string | number | bigint;
+          is_open?: boolean;
+          collateral_token?: string;
+          decimals?: number;
+          campaigns?: Array<string>;
+        };
+        action: "mission.update";
+      }
+  >;
+};
+
+export type CreateProposalResponseDto = {
+  proposal_id: string;
+  total_items_changed: number;
+  estimated_cost: number;
+};
+
+export type GetProposalsResponseDto = {
+  proposals: Array<{
+    id: string;
+    name: string;
+    created_at: Date;
+    created_by: string;
+    total_items: number;
+    pending_count: number;
+    dispatched_count: number;
+    verified_count: number;
+    failed_count: number;
+    status:
+      | "pending"
+      | "approved"
+      | "rejected"
+      | "dispatched"
+      | "verified"
+      | "error";
+  }>;
+  hasNextPage: boolean;
+};
+
+export type GetProposalResponseDto = {
+  id: string;
+  name: string;
+  description: string;
+  source: {
+    tool: "arcgis-plugin";
+    version?: string;
+  };
+  created_at: Date;
+  created_by: string;
+  total_items: number;
+  pending_count: number;
+  dispatched_count: number;
+  verified_count: number;
+  failed_count: number;
+  estimated_cost: string;
+  status:
+    | "pending"
+    | "approved"
+    | "rejected"
+    | "dispatched"
+    | "verified"
+    | "error";
+  changes: Array<{
+    id: string;
+    resource: string;
+    action: string;
+    resource_id: string;
+    payload: {
+      [key: string]: unknown;
+    };
+    dispatched_at: Date;
+    verified_at: Date;
+    failed_at: Date;
+    error: string;
+  }>;
+};
+
+export type ReviewProposalRequestDto = {
+  approved: boolean;
+  reviewed_by: string;
+};
+
+export type ReviewProposalResponseDto = {
+  review_id: string;
+};
+
 export type TriggerPayoutRequestDto = {
   missionIds: Array<string>;
 };
@@ -1074,49 +1274,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 +1424,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 +1442,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,836 +1460,2029 @@ 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 ConditionsControllerGetSunAltitudeTimeLimitsData = {
+export type CampaignsControllerGetMany0V1Data = {
   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: "/conditions/sun-altitude";
+  query?: never;
+  url: "/v1/campaigns";
 };
 
-export type ConditionsControllerGetSunAltitudeTimeLimitsResponses = {
+export type CampaignsControllerGetMany0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type CampaignsControllerGetMany0V1Responses = {
+  200: GetCampaignsResponse;
+};
+
+export type CampaignsControllerGetMany0V1Response =
+  CampaignsControllerGetMany0V1Responses[keyof CampaignsControllerGetMany0V1Responses];
+
+export type CampaignsControllerCreate0V1Data = {
+  body: CreateCampaignBody;
+  path?: never;
+  query?: never;
+  url: "/v1/campaigns";
+};
+
+export type CampaignsControllerCreate0V1Errors = {
+  401: unknown;
+  403: unknown;
   /**
-   * Returns sun altitude time limits for given coordinates and time
+   * Campaign name already exists
    */
-  200: GetTimeLimitsForSunAltitudeResponse;
+  409: unknown;
 };
 
-export type ConditionsControllerGetSunAltitudeTimeLimitsResponse =
-  ConditionsControllerGetSunAltitudeTimeLimitsResponses[keyof ConditionsControllerGetSunAltitudeTimeLimitsResponses];
+export type CampaignsControllerCreate0V1Responses = {
+  201: CreateCampaignResponse;
+};
+
+export type CampaignsControllerCreate0V1Response =
+  CampaignsControllerCreate0V1Responses[keyof CampaignsControllerCreate0V1Responses];
 
-export type ContractsControllerGetAllContractsData = {
+export type CampaignsControllerGetMany1Data = {
   body?: never;
   path?: never;
   query?: never;
-  url: "/contracts";
+  url: "/campaigns";
 };
 
-export type ContractsControllerGetAllContractsErrors = {
+export type CampaignsControllerGetMany1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type ContractsControllerGetAllContractsResponses = {
-  /**
-   * Contracts retrieved successfully
-   */
-  200: GetContractsResponseDto;
+export type CampaignsControllerGetMany1Responses = {
+  200: GetCampaignsResponse;
 };
 
-export type ContractsControllerGetAllContractsResponse =
-  ContractsControllerGetAllContractsResponses[keyof ContractsControllerGetAllContractsResponses];
+export type CampaignsControllerGetMany1Response =
+  CampaignsControllerGetMany1Responses[keyof CampaignsControllerGetMany1Responses];
 
-export type ContractsControllerCreateContractData = {
-  body: CreateContractRequestDto;
+export type CampaignsControllerCreate1Data = {
+  body: CreateCampaignBody;
   path?: never;
   query?: never;
-  url: "/contracts";
+  url: "/campaigns";
 };
 
-export type ContractsControllerCreateContractErrors = {
-  /**
-   * Validation failed
-   */
-  400: unknown;
+export type CampaignsControllerCreate1Errors = {
   401: unknown;
   403: unknown;
   /**
-   * Contract with this address already exists
+   * Campaign name already exists
    */
   409: unknown;
 };
 
-export type ContractsControllerCreateContractResponses = {
-  /**
-   * Contract created successfully
-   */
-  201: CreateContractResponseDto;
+export type CampaignsControllerCreate1Responses = {
+  201: CreateCampaignResponse;
 };
 
-export type ContractsControllerCreateContractResponse =
-  ContractsControllerCreateContractResponses[keyof ContractsControllerCreateContractResponses];
+export type CampaignsControllerCreate1Response =
+  CampaignsControllerCreate1Responses[keyof CampaignsControllerCreate1Responses];
 
-export type ContractsControllerDeleteContractData = {
+export type CampaignsControllerDelete0V1Data = {
   body?: never;
   path: {
-    id: number;
+    id: string;
   };
   query?: never;
-  url: "/contracts/{id}";
+  url: "/v1/campaigns/{id}";
 };
 
-export type ContractsControllerDeleteContractErrors = {
+export type CampaignsControllerDelete0V1Errors = {
   401: unknown;
   403: unknown;
   /**
-   * Contract not found
+   * Campaign is referenced by one or more missions
    */
-  404: unknown;
+  409: unknown;
 };
 
-export type ContractsControllerDeleteContractResponses = {
-  /**
-   * Contract deleted successfully
-   */
-  200: DeleteContractResponseDto;
+export type CampaignsControllerDelete0V1Responses = {
+  200: DeleteCampaignResponse;
 };
 
-export type ContractsControllerDeleteContractResponse =
-  ContractsControllerDeleteContractResponses[keyof ContractsControllerDeleteContractResponses];
+export type CampaignsControllerDelete0V1Response =
+  CampaignsControllerDelete0V1Responses[keyof CampaignsControllerDelete0V1Responses];
 
-export type ContractsControllerGetContractData = {
+export type CampaignsControllerGet0V1Data = {
   body?: never;
   path: {
-    id: number;
+    id: string;
   };
   query?: never;
-  url: "/contracts/{id}";
+  url: "/v1/campaigns/{id}";
 };
 
-export type ContractsControllerGetContractErrors = {
+export type CampaignsControllerGet0V1Errors = {
   401: unknown;
   403: unknown;
   /**
-   * Contract not found
+   * Campaign not found
    */
   404: unknown;
 };
 
-export type ContractsControllerGetContractResponses = {
-  /**
-   * Contract retrieved successfully
-   */
-  200: GetContractResponseDto;
+export type CampaignsControllerGet0V1Responses = {
+  200: GetCampaignResponse;
 };
 
-export type ContractsControllerGetContractResponse =
-  ContractsControllerGetContractResponses[keyof ContractsControllerGetContractResponses];
+export type CampaignsControllerGet0V1Response =
+  CampaignsControllerGet0V1Responses[keyof CampaignsControllerGet0V1Responses];
 
-export type ContractsControllerUpdateContractData = {
-  body: UpdateContractRequestDto;
+export type CampaignsControllerUpdate0V1Data = {
+  body: UpdateCampaignBody;
   path: {
-    id: number;
+    id: string;
   };
   query?: never;
-  url: "/contracts/{id}";
+  url: "/v1/campaigns/{id}";
 };
 
-export type ContractsControllerUpdateContractErrors = {
+export type CampaignsControllerUpdate0V1Errors = {
   401: unknown;
   403: unknown;
   /**
-   * Contract not found
+   * Campaign not found
    */
   404: unknown;
   /**
-   * Contract with this address already exists
+   * Campaign name already exists
    */
   409: unknown;
 };
 
-export type ContractsControllerUpdateContractResponses = {
-  /**
-   * Contract updated successfully
-   */
-  200: UpdateContractResponseDto;
+export type CampaignsControllerUpdate0V1Responses = {
+  200: UpdateCampaignResponse;
 };
 
-export type ContractsControllerUpdateContractResponse =
-  ContractsControllerUpdateContractResponses[keyof ContractsControllerUpdateContractResponses];
+export type CampaignsControllerUpdate0V1Response =
+  CampaignsControllerUpdate0V1Responses[keyof CampaignsControllerUpdate0V1Responses];
 
-export type DlqRedriverControllerRedriveDlqData = {
-  body: RedriveDlqRequestDto;
-  path?: never;
+export type CampaignsControllerDelete1Data = {
+  body?: never;
+  path: {
+    id: string;
+  };
   query?: never;
-  url: "/dlq-redriver/redrive";
+  url: "/campaigns/{id}";
 };
 
-export type DlqRedriverControllerRedriveDlqErrors = {
-  /**
-   * Invalid request parameters
-   */
-  400: unknown;
+export type CampaignsControllerDelete1Errors = {
   401: unknown;
   403: unknown;
   /**
-   * Error during DLQ redrive
+   * Campaign is referenced by one or more missions
    */
-  500: unknown;
+  409: unknown;
 };
 
-export type DlqRedriverControllerRedriveDlqResponses = {
-  /**
-   * DLQ redrive completed successfully
-   */
-  200: RedriveDlqResponseDto;
+export type CampaignsControllerDelete1Responses = {
+  200: DeleteCampaignResponse;
 };
 
-export type DlqRedriverControllerRedriveDlqResponse =
-  DlqRedriverControllerRedriveDlqResponses[keyof DlqRedriverControllerRedriveDlqResponses];
+export type CampaignsControllerDelete1Response =
+  CampaignsControllerDelete1Responses[keyof CampaignsControllerDelete1Responses];
 
-export type FlightsControllerGenerateStorageKeyData = {
+export type CampaignsControllerGet1Data = {
+  body?: never;
+  path: {
+    id: string;
+  };
+  query?: never;
+  url: "/campaigns/{id}";
+};
+
+export type CampaignsControllerGet1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Campaign not found
+   */
+  404: unknown;
+};
+
+export type CampaignsControllerGet1Responses = {
+  200: GetCampaignResponse;
+};
+
+export type CampaignsControllerGet1Response =
+  CampaignsControllerGet1Responses[keyof CampaignsControllerGet1Responses];
+
+export type CampaignsControllerUpdate1Data = {
+  body: UpdateCampaignBody;
+  path: {
+    id: string;
+  };
+  query?: never;
+  url: "/campaigns/{id}";
+};
+
+export type CampaignsControllerUpdate1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Campaign not found
+   */
+  404: unknown;
+  /**
+   * Campaign name already exists
+   */
+  409: unknown;
+};
+
+export type CampaignsControllerUpdate1Responses = {
+  200: UpdateCampaignResponse;
+};
+
+export type CampaignsControllerUpdate1Response =
+  CampaignsControllerUpdate1Responses[keyof CampaignsControllerUpdate1Responses];
+
+export type ConditionsControllerGetSunAltitudeTimeLimits0V1Data = {
   body?: never;
   path?: never;
   query: {
-    missionId: string | number | bigint;
-    pilotAddress: string;
-    flightTimestamp?: string;
+    /**
+     * 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: "/flights/storage-key";
+  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 ConditionsControllerGetSunAltitudeTimeLimits1Data = {
+  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: "/conditions/sun-altitude";
+};
+
+export type ConditionsControllerGetSunAltitudeTimeLimits1Responses = {
+  /**
+   * Returns sun altitude time limits for given coordinates and time
+   */
+  200: GetTimeLimitsForSunAltitudeResponse;
+};
+
+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 ContractsControllerGetAllContracts1Data = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: "/contracts";
+};
+
+export type ContractsControllerGetAllContracts1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type ContractsControllerGetAllContracts1Responses = {
+  /**
+   * Contracts retrieved successfully
+   */
+  200: GetContractsResponseDto;
+};
+
+export type ContractsControllerGetAllContracts1Response =
+  ContractsControllerGetAllContracts1Responses[keyof ContractsControllerGetAllContracts1Responses];
+
+export type ContractsControllerCreateContract1Data = {
+  body: CreateContractRequestDto;
+  path?: never;
+  query?: never;
+  url: "/contracts";
+};
+
+export type ContractsControllerCreateContract1Errors = {
+  /**
+   * Validation failed
+   */
+  400: unknown;
+  401: unknown;
+  403: unknown;
+  /**
+   * Contract with this address already exists
+   */
+  409: unknown;
+};
+
+export type ContractsControllerCreateContract1Responses = {
+  /**
+   * Contract created successfully
+   */
+  201: CreateContractResponseDto;
+};
+
+export type ContractsControllerCreateContract1Response =
+  ContractsControllerCreateContract1Responses[keyof ContractsControllerCreateContract1Responses];
+
+export type ContractsControllerDeleteContract0V1Data = {
+  body?: never;
+  path: {
+    id: number;
+  };
+  query?: never;
+  url: "/v1/contracts/{id}";
+};
+
+export type ContractsControllerDeleteContract0V1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Contract not found
+   */
+  404: unknown;
+};
+
+export type ContractsControllerDeleteContract0V1Responses = {
+  /**
+   * Contract deleted successfully
+   */
+  200: DeleteContractResponseDto;
+};
+
+export type ContractsControllerDeleteContract0V1Response =
+  ContractsControllerDeleteContract0V1Responses[keyof ContractsControllerDeleteContract0V1Responses];
+
+export type ContractsControllerGetContract0V1Data = {
+  body?: never;
+  path: {
+    id: number;
+  };
+  query?: never;
+  url: "/v1/contracts/{id}";
+};
+
+export type ContractsControllerGetContract0V1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Contract not found
+   */
+  404: unknown;
+};
+
+export type ContractsControllerGetContract0V1Responses = {
+  /**
+   * Contract retrieved successfully
+   */
+  200: GetContractResponseDto;
+};
+
+export type ContractsControllerGetContract0V1Response =
+  ContractsControllerGetContract0V1Responses[keyof ContractsControllerGetContract0V1Responses];
+
+export type ContractsControllerUpdateContract0V1Data = {
+  body: UpdateContractRequestDto;
+  path: {
+    id: number;
+  };
+  query?: never;
+  url: "/v1/contracts/{id}";
+};
+
+export type ContractsControllerUpdateContract0V1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Contract not found
+   */
+  404: unknown;
+  /**
+   * Contract with this address already exists
+   */
+  409: unknown;
+};
+
+export type ContractsControllerUpdateContract0V1Responses = {
+  /**
+   * Contract updated successfully
+   */
+  200: UpdateContractResponseDto;
+};
+
+export type ContractsControllerUpdateContract0V1Response =
+  ContractsControllerUpdateContract0V1Responses[keyof ContractsControllerUpdateContract0V1Responses];
+
+export type ContractsControllerDeleteContract1Data = {
+  body?: never;
+  path: {
+    id: number;
+  };
+  query?: never;
+  url: "/contracts/{id}";
+};
+
+export type ContractsControllerDeleteContract1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Contract not found
+   */
+  404: unknown;
+};
+
+export type ContractsControllerDeleteContract1Responses = {
+  /**
+   * Contract deleted successfully
+   */
+  200: DeleteContractResponseDto;
+};
+
+export type ContractsControllerDeleteContract1Response =
+  ContractsControllerDeleteContract1Responses[keyof ContractsControllerDeleteContract1Responses];
+
+export type ContractsControllerGetContract1Data = {
+  body?: never;
+  path: {
+    id: number;
+  };
+  query?: never;
+  url: "/contracts/{id}";
+};
+
+export type ContractsControllerGetContract1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Contract not found
+   */
+  404: unknown;
+};
+
+export type ContractsControllerGetContract1Responses = {
+  /**
+   * Contract retrieved successfully
+   */
+  200: GetContractResponseDto;
+};
+
+export type ContractsControllerGetContract1Response =
+  ContractsControllerGetContract1Responses[keyof ContractsControllerGetContract1Responses];
+
+export type ContractsControllerUpdateContract1Data = {
+  body: UpdateContractRequestDto;
+  path: {
+    id: number;
+  };
+  query?: never;
+  url: "/contracts/{id}";
+};
+
+export type ContractsControllerUpdateContract1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Contract not found
+   */
+  404: unknown;
+  /**
+   * Contract with this address already exists
+   */
+  409: unknown;
+};
+
+export type ContractsControllerUpdateContract1Responses = {
+  /**
+   * Contract updated successfully
+   */
+  200: UpdateContractResponseDto;
+};
+
+export type ContractsControllerUpdateContract1Response =
+  ContractsControllerUpdateContract1Responses[keyof ContractsControllerUpdateContract1Responses];
+
+export type DlqRedriverControllerRedriveDlq0V1Data = {
+  body: RedriveDlqRequestDto;
+  path?: never;
+  query?: never;
+  url: "/v1/dlq-redriver/redrive";
+};
+
+export type DlqRedriverControllerRedriveDlq0V1Errors = {
+  /**
+   * Invalid request parameters
+   */
+  400: unknown;
+  401: unknown;
+  403: unknown;
+  /**
+   * Error during DLQ redrive
+   */
+  500: unknown;
+};
+
+export type DlqRedriverControllerRedriveDlq0V1Responses = {
+  /**
+   * DLQ redrive completed successfully
+   */
+  200: RedriveDlqResponseDto;
+};
+
+export type DlqRedriverControllerRedriveDlq0V1Response =
+  DlqRedriverControllerRedriveDlq0V1Responses[keyof DlqRedriverControllerRedriveDlq0V1Responses];
+
+export type DlqRedriverControllerRedriveDlq1Data = {
+  body: RedriveDlqRequestDto;
+  path?: never;
+  query?: never;
+  url: "/dlq-redriver/redrive";
+};
+
+export type DlqRedriverControllerRedriveDlq1Errors = {
+  /**
+   * Invalid request parameters
+   */
+  400: unknown;
+  401: unknown;
+  403: unknown;
+  /**
+   * Error during DLQ redrive
+   */
+  500: unknown;
+};
+
+export type DlqRedriverControllerRedriveDlq1Responses = {
+  /**
+   * DLQ redrive completed successfully
+   */
+  200: RedriveDlqResponseDto;
+};
+
+export type DlqRedriverControllerRedriveDlq1Response =
+  DlqRedriverControllerRedriveDlq1Responses[keyof DlqRedriverControllerRedriveDlq1Responses];
+
+export type FlightsControllerGenerateStorageKey0V1Data = {
+  body?: never;
+  path?: never;
+  query: {
+    missionId: string | number | bigint;
+    pilotAddress: string;
+    flightTimestamp?: string;
+  };
+  url: "/v1/flights/storage-key";
+};
+
+export type FlightsControllerGenerateStorageKey0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightsControllerGenerateStorageKey0V1Responses = {
+  /**
+   * Returns the generated storage key
+   */
+  200: string;
+};
+
+export type FlightsControllerGenerateStorageKey0V1Response =
+  FlightsControllerGenerateStorageKey0V1Responses[keyof FlightsControllerGenerateStorageKey0V1Responses];
+
+export type FlightsControllerGenerateStorageKey1Data = {
+  body?: never;
+  path?: never;
+  query: {
+    missionId: string | number | bigint;
+    pilotAddress: string;
+    flightTimestamp?: string;
+  };
+  url: "/flights/storage-key";
+};
+
+export type FlightsControllerGenerateStorageKey1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightsControllerGenerateStorageKey1Responses = {
+  /**
+   * Returns the generated storage key
+   */
+  200: string;
+};
+
+export type FlightsControllerGenerateStorageKey1Response =
+  FlightsControllerGenerateStorageKey1Responses[keyof FlightsControllerGenerateStorageKey1Responses];
+
+export type FlightsControllerGetFlight0V1Data = {
+  body?: never;
+  path: {
+    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 FlightPlansControllerGet1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightPlansControllerGet1Responses = {
+  200: GetFlightPlanResponse;
+};
+
+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 FlightReviewsControllerGetFlightReview1Data = {
+  body?: never;
+  path: {
+    id: bigint;
+  };
+  query?: never;
+  url: "/flight-reviews/{id}";
+};
+
+export type FlightReviewsControllerGetFlightReview1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Flight review not found
+   */
+  404: unknown;
+};
+
+export type FlightReviewsControllerGetFlightReview1Responses = {
+  200: GetFlightReviewResponseDto;
+};
+
+export type FlightReviewsControllerGetFlightReview1Response =
+  FlightReviewsControllerGetFlightReview1Responses[keyof FlightReviewsControllerGetFlightReview1Responses];
+
+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: {
+    updated_at_gt: Date;
+    updated_at_lt: Date;
+  };
+  url: "/flight-reviews";
+};
+
+export type FlightReviewsControllerGetFlightReviews1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type FlightReviewsControllerGetFlightReviews1Responses = {
+  200: GetFlightReviewsResponseDto;
+};
+
+export type FlightReviewsControllerGetFlightReviews1Response =
+  FlightReviewsControllerGetFlightReviews1Responses[keyof FlightReviewsControllerGetFlightReviews1Responses];
+
+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 KeysControllerGetProvenanceCryptoKey1Responses = {
+  200: GetProvenanceCryptoKeyResponse;
+};
+
+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 MissionsControllerGetMission1Data = {
+  body?: never;
+  path: {
+    id: string;
+  };
+  query?: {
+    relations?:
+      | "vault"
+      | "payout"
+      | "campaigns"
+      | Array<"vault" | "payout" | "campaigns">;
+  };
+  url: "/missions/{id}";
+};
+
+export type MissionsControllerGetMission1Errors = {
+  401: unknown;
+  403: unknown;
+  /**
+   * Mission not found
+   */
+  404: unknown;
+};
+
+export type MissionsControllerGetMission1Responses = {
+  200: GetMissionResponseDto;
+};
+
+export type MissionsControllerGetMission1Response =
+  MissionsControllerGetMission1Responses[keyof MissionsControllerGetMission1Responses];
+
+export type MissionsControllerGetMissions0V1Data = {
+  body?: never;
+  path?: never;
+  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: "/v1/missions";
+};
+
+export type MissionsControllerGetMissions0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type MissionsControllerGetMissions0V1Responses = {
+  200: GetMissionsResponseDto;
+};
+
+export type MissionsControllerGetMissions0V1Response =
+  MissionsControllerGetMissions0V1Responses[keyof MissionsControllerGetMissions0V1Responses];
+
+export type MissionsControllerCreateMissions0V1Data = {
+  body: CreateMissionRequestDto;
+  path?: never;
+  query?: never;
+  url: "/v1/missions";
+};
+
+export type MissionsControllerCreateMissions0V1Errors = {
+  /**
+   * 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 MissionsControllerCreateMissions0V1Responses = {
+  /**
+   * Transaction to create mission, queued successfully
+   */
+  201: CreateMissionResponseDto;
+};
+
+export type MissionsControllerCreateMissions0V1Response =
+  MissionsControllerCreateMissions0V1Responses[keyof MissionsControllerCreateMissions0V1Responses];
+
+export type MissionsControllerUpdateMissions0V1Data = {
+  body: UpdateMissionsRequestDto;
+  path?: never;
+  query?: never;
+  url: "/v1/missions";
+};
+
+export type MissionsControllerUpdateMissions0V1Errors = {
+  401: unknown;
+  403: unknown;
+};
+
+export type MissionsControllerUpdateMissions0V1Responses = {
+  /**
+   * Missions update transaction queued successfully
+   */
+  200: UpdateMissionsResponseDto;
+};
+
+export type MissionsControllerUpdateMissions0V1Response =
+  MissionsControllerUpdateMissions0V1Responses[keyof MissionsControllerUpdateMissions0V1Responses];
+
+export type MissionsControllerGetMissions1Data = {
+  body?: never;
+  path?: never;
+  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 MissionsControllerRepriceMissions0V1Response =
+  MissionsControllerRepriceMissions0V1Responses[keyof MissionsControllerRepriceMissions0V1Responses];
+
+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 ListProposalsData = {
+  body?: never;
+  path?: never;
+  query?: {
+    status?:
+      | "pending"
+      | "approved"
+      | "rejected"
+      | "dispatched"
+      | "verified"
+      | "error";
+    created_by?: string;
+    created_after?: Date;
+    created_before?: Date;
+    page?: number;
+  };
+  url: "/v1/proposals";
+};
+
+export type ListProposalsErrors = {
+  /**
+   * Missing manageProposals permission
+   */
+  403: unknown;
+};
+
+export type ListProposalsResponses = {
+  200: GetProposalsResponseDto;
+};
+
+export type ListProposalsResponse =
+  ListProposalsResponses[keyof ListProposalsResponses];
+
+export type SubmitProposalData = {
+  body: CreateProposalRequestDto;
+  path?: never;
+  query?: never;
+  url: "/v1/proposals";
 };
 
-export type FlightsControllerGenerateStorageKeyErrors = {
+export type SubmitProposalErrors = {
+  /**
+   * Schema validation failed
+   */
+  400: unknown;
   401: unknown;
   403: unknown;
 };
 
-export type FlightsControllerGenerateStorageKeyResponses = {
-  /**
-   * Returns the generated storage key
-   */
-  200: string;
+export type SubmitProposalResponses = {
+  201: CreateProposalResponseDto;
 };
 
-export type FlightsControllerGenerateStorageKeyResponse =
-  FlightsControllerGenerateStorageKeyResponses[keyof FlightsControllerGenerateStorageKeyResponses];
+export type SubmitProposalResponse =
+  SubmitProposalResponses[keyof SubmitProposalResponses];
 
-export type FlightsControllerGetFlightData = {
+export type GetProposalData = {
   body?: never;
   path: {
-    flightId: bigint;
+    id: string;
   };
   query?: never;
-  url: "/flights/{flightId}";
+  url: "/v1/proposals/{id}";
 };
 
-export type FlightsControllerGetFlightErrors = {
-  401: unknown;
+export type GetProposalErrors = {
+  /**
+   * Missing manageProposals permission
+   */
   403: unknown;
-};
-
-export type FlightsControllerGetFlightResponses = {
   /**
-   * Returns flight details
+   * Proposal not found
    */
-  200: FlightDto;
+  404: unknown;
+};
+
+export type GetProposalResponses = {
+  200: GetProposalResponseDto;
 };
 
-export type FlightsControllerGetFlightResponse =
-  FlightsControllerGetFlightResponses[keyof FlightsControllerGetFlightResponses];
+export type GetProposalResponse =
+  GetProposalResponses[keyof GetProposalResponses];
 
-export type FlightsControllerCreatePresignedUrlsData = {
-  body: CreateFileRequestDto;
-  path?: never;
+export type ReviewProposalData = {
+  body: ReviewProposalRequestDto;
+  path: {
+    id: string;
+  };
   query?: never;
-  url: "/flights/files";
+  url: "/v1/proposals/{id}/review";
 };
 
-export type FlightsControllerCreatePresignedUrlsErrors = {
+export type ReviewProposalErrors = {
   401: unknown;
   403: unknown;
-};
-
-export type FlightsControllerCreatePresignedUrlsResponses = {
   /**
-   * Returns presigned URLs for file upload
+   * Proposal not found
    */
-  201: CreateFileResponseDto;
+  404: unknown;
+  /**
+   * Another proposal is already running
+   */
+  409: unknown;
+};
+
+export type ReviewProposalResponses = {
+  200: ReviewProposalResponseDto;
 };
 
-export type FlightsControllerCreatePresignedUrlsResponse =
-  FlightsControllerCreatePresignedUrlsResponses[keyof FlightsControllerCreatePresignedUrlsResponses];
+export type ReviewProposalResponse =
+  ReviewProposalResponses[keyof ReviewProposalResponses];
 
-export type FlightsControllerValidateFlightData = {
-  body: ValidateFlightRequestDto;
+export type ProtocolTriggersApiControllerTriggerPayout0V1Data = {
+  body: TriggerPayoutRequestDto;
   path?: never;
   query?: never;
-  url: "/flights";
+  url: "/v1/protocol-triggers/missions/payout";
 };
 
-export type FlightsControllerValidateFlightErrors = {
+export type ProtocolTriggersApiControllerTriggerPayout0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type FlightsControllerValidateFlightResponses = {
-  /**
-   * Result to track queued flight through its validation
-   */
-  200: ValidateFlightResponseDto;
+export type ProtocolTriggersApiControllerTriggerPayout0V1Responses = {
+  201: unknown;
 };
 
-export type FlightsControllerValidateFlightResponse =
-  FlightsControllerValidateFlightResponses[keyof FlightsControllerValidateFlightResponses];
-
-export type FlightPlansControllerGetManyData = {
-  body?: never;
+export type ProtocolTriggersApiControllerTriggerPayout1Data = {
+  body: TriggerPayoutRequestDto;
   path?: never;
   query?: never;
-  url: "/flight-plans";
+  url: "/protocol-triggers/missions/payout";
 };
 
-export type FlightPlansControllerGetManyErrors = {
+export type ProtocolTriggersApiControllerTriggerPayout1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type FlightPlansControllerGetManyResponses = {
-  200: GetFlightPlansResponse;
+export type ProtocolTriggersApiControllerTriggerPayout1Responses = {
+  201: unknown;
 };
 
-export type FlightPlansControllerGetManyResponse =
-  FlightPlansControllerGetManyResponses[keyof FlightPlansControllerGetManyResponses];
-
-export type FlightPlansControllerCreateData = {
-  body: CreateFlightPlanBody;
+export type ProtocolTriggersApiControllerTriggerMissionClose0V1Data = {
+  body: TriggerMissionCloseRequestDto;
   path?: never;
   query?: never;
-  url: "/flight-plans";
+  url: "/v1/protocol-triggers/missions/close";
 };
 
-export type FlightPlansControllerCreateErrors = {
+export type ProtocolTriggersApiControllerTriggerMissionClose0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type FlightPlansControllerCreateResponses = {
-  201: CreateFlightPlanResponse;
+export type ProtocolTriggersApiControllerTriggerMissionClose0V1Responses = {
+  201: unknown;
 };
 
-export type FlightPlansControllerCreateResponse =
-  FlightPlansControllerCreateResponses[keyof FlightPlansControllerCreateResponses];
-
-export type FlightPlansControllerGetData = {
-  body?: never;
-  path: {
-    id: number;
-  };
+export type ProtocolTriggersApiControllerTriggerMissionClose1Data = {
+  body: TriggerMissionCloseRequestDto;
+  path?: never;
   query?: never;
-  url: "/flight-plans/{id}";
+  url: "/protocol-triggers/missions/close";
 };
 
-export type FlightPlansControllerGetErrors = {
+export type ProtocolTriggersApiControllerTriggerMissionClose1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type FlightPlansControllerGetResponses = {
-  200: GetFlightPlanResponse;
+export type ProtocolTriggersApiControllerTriggerMissionClose1Responses = {
+  201: unknown;
 };
 
-export type FlightPlansControllerGetResponse =
-  FlightPlansControllerGetResponses[keyof FlightPlansControllerGetResponses];
-
-export type FlightReviewsControllerGetFlightReviewData = {
-  body?: never;
-  path: {
-    id: bigint;
-  };
+export type QuotesControllerCreateQuote0V1Data = {
+  body: CreateQuoteRequestDto;
+  path?: never;
   query?: never;
-  url: "/flight-reviews/{id}";
+  url: "/v1/quotes";
 };
 
-export type FlightReviewsControllerGetFlightReviewErrors = {
+export type QuotesControllerCreateQuote0V1Errors = {
   401: unknown;
   403: unknown;
-  /**
-   * Flight review not found
-   */
-  404: unknown;
 };
 
-export type FlightReviewsControllerGetFlightReviewResponses = {
-  200: GetFlightReviewResponseDto;
+export type QuotesControllerCreateQuote0V1Responses = {
+  201: unknown;
 };
 
-export type FlightReviewsControllerGetFlightReviewResponse =
-  FlightReviewsControllerGetFlightReviewResponses[keyof FlightReviewsControllerGetFlightReviewResponses];
-
-export type FlightReviewsControllerGetFlightReviewsData = {
-  body?: never;
+export type QuotesControllerCreateQuote1Data = {
+  body: CreateQuoteRequestDto;
   path?: never;
-  query: {
-    updated_at_gt: Date;
-    updated_at_lt: Date;
-  };
-  url: "/flight-reviews";
+  query?: never;
+  url: "/quotes";
 };
 
-export type FlightReviewsControllerGetFlightReviewsErrors = {
+export type QuotesControllerCreateQuote1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type FlightReviewsControllerGetFlightReviewsResponses = {
-  200: GetFlightReviewsResponseDto;
+export type QuotesControllerCreateQuote1Responses = {
+  201: unknown;
 };
 
-export type FlightReviewsControllerGetFlightReviewsResponse =
-  FlightReviewsControllerGetFlightReviewsResponses[keyof FlightReviewsControllerGetFlightReviewsResponses];
-
-export type KeysControllerGetProvenanceCryptoKeyData = {
+export type QuotesControllerGetQuote0V1Data = {
   body?: never;
-  path?: never;
+  path: {
+    id: string;
+  };
   query?: never;
-  url: "/keys";
+  url: "/v1/quotes/{id}";
 };
 
-export type KeysControllerGetProvenanceCryptoKeyResponses = {
-  200: GetProvenanceCryptoKeyResponse;
+export type QuotesControllerGetQuote0V1Errors = {
+  401: unknown;
+  403: unknown;
 };
 
-export type KeysControllerGetProvenanceCryptoKeyResponse =
-  KeysControllerGetProvenanceCryptoKeyResponses[keyof KeysControllerGetProvenanceCryptoKeyResponses];
+export type QuotesControllerGetQuote0V1Responses = {
+  200: unknown;
+};
 
-export type MissionsControllerGetMissionData = {
+export type QuotesControllerGetQuote1Data = {
   body?: never;
   path: {
     id: string;
   };
-  query?: {
-    relations?:
-      | "vault"
-      | "payout"
-      | "campaigns"
-      | Array<"vault" | "payout" | "campaigns">;
-  };
-  url: "/missions/{id}";
+  query?: never;
+  url: "/quotes/{id}";
 };
 
-export type MissionsControllerGetMissionErrors = {
+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 = {
   /**
-   * Mission not found
+   * Get event schema
    */
-  404: unknown;
+  200: unknown;
 };
 
-export type MissionsControllerGetMissionResponses = {
-  200: GetMissionResponseDto;
+export type SchemaControllerGetEventSchema1Data = {
+  body?: never;
+  path?: never;
+  query?: never;
+  url: "/schema/event";
 };
 
-export type MissionsControllerGetMissionResponse =
-  MissionsControllerGetMissionResponses[keyof MissionsControllerGetMissionResponses];
+export type SchemaControllerGetEventSchema1Responses = {
+  /**
+   * Get event schema
+   */
+  200: unknown;
+};
 
-export type MissionsControllerGetMissionsData = {
-  body?: never;
+export type VaultsControllerCreateVaults0V1Data = {
+  body: CreateVaultsRequestDto;
   path?: never;
-  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";
+  query?: never;
+  url: "/v1/vaults";
 };
 
-export type MissionsControllerGetMissionsErrors = {
+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 MissionsControllerGetMissionsResponses = {
-  200: GetMissionsResponseDto;
+export type VaultsControllerCreateVaults0V1Responses = {
+  /**
+   * Vault requests posted successfully
+   */
+  201: CreateVaultsResponseDto;
 };
 
-export type MissionsControllerGetMissionsResponse =
-  MissionsControllerGetMissionsResponses[keyof MissionsControllerGetMissionsResponses];
+export type VaultsControllerCreateVaults0V1Response =
+  VaultsControllerCreateVaults0V1Responses[keyof VaultsControllerCreateVaults0V1Responses];
 
-export type MissionsControllerCreateMissionsData = {
-  body: CreateMissionRequestDto;
+export type VaultsControllerCreateVaults1Data = {
+  body: CreateVaultsRequestDto;
   path?: never;
   query?: never;
-  url: "/missions";
+  url: "/vaults";
 };
 
-export type MissionsControllerCreateMissionsErrors = {
+export type VaultsControllerCreateVaults1Errors = {
   /**
-   * Validation failed - invalid Zones, mission types, or times
+   * Validation failed - invalid funder, amount, or contract address
    */
   400: unknown;
   401: unknown;
-  /**
-   * Insufficient treasury spending limit
-   */
   403: unknown;
   /**
-   * Internal server error during mission creation
+   * Internal server error during vault request creation
    */
   500: unknown;
 };
 
-export type MissionsControllerCreateMissionsResponses = {
+export type VaultsControllerCreateVaults1Responses = {
   /**
-   * Transaction to create mission, queued successfully
+   * Vault requests posted successfully
    */
-  201: CreateMissionResponseDto;
+  201: CreateVaultsResponseDto;
 };
 
-export type MissionsControllerCreateMissionsResponse =
-  MissionsControllerCreateMissionsResponses[keyof MissionsControllerCreateMissionsResponses];
+export type VaultsControllerCreateVaults1Response =
+  VaultsControllerCreateVaults1Responses[keyof VaultsControllerCreateVaults1Responses];
 
-export type MissionsControllerUpdateMissionsData = {
-  body: UpdateMissionsRequestDto;
-  path?: never;
+export type WebhooksControllerGetMany0V1Data = {
+  body?: never;
+  path: {
+    org_id: number;
+  };
   query?: never;
-  url: "/missions";
+  url: "/v1/org/{org_id}/webhooks";
 };
 
-export type MissionsControllerUpdateMissionsErrors = {
+export type WebhooksControllerGetMany0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type MissionsControllerUpdateMissionsResponses = {
-  /**
-   * Missions update transaction queued successfully
-   */
-  200: UpdateMissionsResponseDto;
+export type WebhooksControllerGetMany0V1Responses = {
+  200: GetWebhooksResponse;
 };
 
-export type MissionsControllerUpdateMissionsResponse =
-  MissionsControllerUpdateMissionsResponses[keyof MissionsControllerUpdateMissionsResponses];
+export type WebhooksControllerGetMany0V1Response =
+  WebhooksControllerGetMany0V1Responses[keyof WebhooksControllerGetMany0V1Responses];
 
-export type MissionsControllerRepriceMissionsData = {
-  body: RepriceMissionsRequestDto;
-  path?: never;
+export type WebhooksControllerCreate0V1Data = {
+  body: CreateWebhookBody;
+  path: {
+    org_id: number;
+  };
   query?: never;
-  url: "/missions/amounts";
+  url: "/v1/org/{org_id}/webhooks";
 };
 
-export type MissionsControllerRepriceMissionsErrors = {
+export type WebhooksControllerCreate0V1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type MissionsControllerRepriceMissionsResponses = {
-  /**
-   * Mission repricing queued successfully
-   */
-  200: RepriceMissionsResponseDto;
+export type WebhooksControllerCreate0V1Responses = {
+  201: CreateWebhookResponse;
 };
 
-export type MissionsControllerRepriceMissionsResponse =
-  MissionsControllerRepriceMissionsResponses[keyof MissionsControllerRepriceMissionsResponses];
+export type WebhooksControllerCreate0V1Response =
+  WebhooksControllerCreate0V1Responses[keyof WebhooksControllerCreate0V1Responses];
 
-export type ProtocolTriggersApiControllerTriggerPayoutData = {
-  body: TriggerPayoutRequestDto;
-  path?: never;
+export type WebhooksControllerGetMany1Data = {
+  body?: never;
+  path: {
+    org_id: number;
+  };
   query?: never;
-  url: "/protocol-triggers/missions/payout";
+  url: "/org/{org_id}/webhooks";
 };
 
-export type ProtocolTriggersApiControllerTriggerPayoutErrors = {
+export type WebhooksControllerGetMany1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type ProtocolTriggersApiControllerTriggerPayoutResponses = {
-  201: unknown;
+export type WebhooksControllerGetMany1Responses = {
+  200: GetWebhooksResponse;
 };
 
-export type ProtocolTriggersApiControllerTriggerMissionCloseData = {
-  body: TriggerMissionCloseRequestDto;
-  path?: never;
+export type WebhooksControllerGetMany1Response =
+  WebhooksControllerGetMany1Responses[keyof WebhooksControllerGetMany1Responses];
+
+export type WebhooksControllerCreate1Data = {
+  body: CreateWebhookBody;
+  path: {
+    org_id: number;
+  };
   query?: never;
-  url: "/protocol-triggers/missions/close";
+  url: "/org/{org_id}/webhooks";
 };
 
-export type ProtocolTriggersApiControllerTriggerMissionCloseErrors = {
+export type WebhooksControllerCreate1Errors = {
   401: unknown;
   403: unknown;
 };
 
-export type ProtocolTriggersApiControllerTriggerMissionCloseResponses = {
-  201: unknown;
+export type WebhooksControllerCreate1Responses = {
+  201: CreateWebhookResponse;
 };
 
-export type QuotesControllerCreateQuoteData = {
-  body: CreateQuoteRequestDto;
-  path?: never;
+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: "/quotes";
+  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 +3492,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 +3551,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 +3620,7 @@ export type ZonesControllerDeleteZoneData = {
   url: "/zones/{id}";
 };
 
-export type ZonesControllerDeleteZoneErrors = {
+export type ZonesControllerDeleteZone1Errors = {
   401: unknown;
   403: unknown;
   /**
@@ -2057,17 +3629,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 +3648,7 @@ export type ZonesControllerUpdateZoneData = {
   url: "/zones/{id}";
 };
 
-export type ZonesControllerUpdateZoneErrors = {
+export type ZonesControllerUpdateZone1Errors = {
   401: unknown;
   403: unknown;
   /**
@@ -2085,49 +3657,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 +3755,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 +3928,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 +3949,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 +3970,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;