@burdenoff/microfe-movethewheels 2026.510.105

package/src/generated/wspace-operations.ts

@@ -0,0 +1,3734 @@
+// @ts-nocheck
+import * as Types from './wspace-types';
+
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+import * as ApolloReactHooks from '@apollo/client/react';
+const defaultOptions = {} as const;
+export type MovethewheelsOrderCoreFragment = { __typename?: 'MovethewheelsOrder', id: string, orderNumber: string, orderType: Types.OrderType, status: Types.OrderStatus, priority: Types.OrderPriority, customerId: string, trackingNumber?: string | null, pickupAddress: Record<string, unknown>, deliveryAddress: Record<string, unknown>, items: Record<string, unknown>, pricing?: Record<string, unknown> | null, scheduledDelivery?: string | null, vehicleId?: string | null, driverId?: string | null, createdAt: string, updatedAt: string };
+
+export type CustomerCoreFragment = { __typename?: 'Customer', id: string, name: string, email?: string | null, phone?: string | null, type: string, company?: string | null, address?: Record<string, unknown> | null, rating?: number | null, createdAt: string, updatedAt: string };
+
+export type ProductCoreFragment = { __typename?: 'Product', id: string, sku: string, name: string, description?: string | null, category?: string | null, brand?: string | null, dimensions?: Record<string, unknown> | null, weight?: number | null, value?: number | null, hazardous: boolean, fragile: boolean, temperatureControlled: boolean, createdAt: string, updatedAt: string };
+
+export type VehicleCoreFragment = { __typename?: 'Vehicle', id: string, vehicleNumber: string, make?: string | null, model?: string | null, year?: number | null, licensePlate?: string | null, type: Types.VehicleType, ownershipType?: string | null, capacity?: Record<string, unknown> | null, status: Types.VehicleStatus, currentLocation?: Record<string, unknown> | null, fuelLevel?: number | null, mileage?: number | null, createdAt: string, updatedAt: string };
+
+export type DriverCoreFragment = { __typename?: 'Driver', id: string, employeeId: string, firstName: string, lastName: string, phone?: string | null, email?: string | null, licenseNumber?: string | null, licenseClass?: string | null, licenseExpiry?: string | null, status: Types.DriverStatus, currentLocation?: Record<string, unknown> | null, rating?: number | null, userId?: string | null, vehicleId?: string | null, createdAt: string, updatedAt: string };
+
+export type WarehouseCoreFragment = { __typename?: 'Warehouse', id: string, name: string, code: string, type: Types.WarehouseType, address: Record<string, unknown>, contactInfo?: Record<string, unknown> | null, operatingHours?: Record<string, unknown> | null, capabilities?: Record<string, unknown> | null, status: string, totalCapacity?: number | null, usedCapacity?: number | null, createdAt: string, updatedAt: string };
+
+export type InventoryItemCoreFragment = { __typename?: 'InventoryItem', id: string, productId: string, warehouseId: string, locationId?: string | null, onHand: number, available: number, allocated: number, damaged: number, unitCost?: number | null, reorderPoint?: number | null, safetyStock?: number | null, createdAt: string, updatedAt: string };
+
+export type RouteCoreFragment = { __typename?: 'Route', id: string, name: string, status: Types.RouteStatus, shipmentId?: string | null, vehicleId?: string | null, driverId?: string | null, waypoints: Record<string, unknown>, estimatedDistance?: number | null, estimatedDuration?: number | null, actualDistance?: number | null, actualDuration?: number | null, fuelCost?: number | null, createdAt: string, updatedAt: string };
+
+export type ShipmentCoreFragment = { __typename?: 'Shipment', id: string, shipmentNumber: string, orderId: string, customerId?: string | null, carrierId?: string | null, status: Types.ShipmentStatus, origin: Record<string, unknown>, destination: Record<string, unknown>, cargoDetails?: Record<string, unknown> | null, trackingNumber?: string | null, estimatedDelivery?: string | null, actualDelivery?: string | null, createdAt: string, updatedAt: string };
+
+export type ServiceProviderCoreFragment = { __typename?: 'ServiceProvider', id: string, name: string, type: string, description?: string | null, rating?: number | null, contactInfo?: Record<string, unknown> | null, services?: Record<string, unknown> | null, isVerified: boolean, isActive: boolean, createdAt: string, updatedAt: string };
+
+export type ServiceOfferingCoreFragment = { __typename?: 'ServiceOffering', id: string, providerId: string, name: string, description?: string | null, category?: string | null, price: number, currency: string, availability?: Record<string, unknown> | null, createdAt: string, updatedAt: string };
+
+export type MovethewheelsReportCoreFragment = { __typename?: 'MovethewheelsReport', id: string, name: string, type: string, description?: string | null, schedule?: string | null, lastGenerated?: string | null, configuration?: Record<string, unknown> | null, status: string, createdAt: string, updatedAt: string };
+
+export type CreateCustomerMutationVariables = Types.Exact<{
+  input: Types.CreateCustomerInput;
+}>;
+
+
+export type CreateCustomerMutation = { __typename?: 'Mutation', createCustomer: { __typename?: 'Customer', id: string, name: string, email?: string | null, phone?: string | null, type: string, company?: string | null, address?: Record<string, unknown> | null, rating?: number | null, createdAt: string, updatedAt: string } };
+
+export type UpdateCustomerMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  input: Types.UpdateCustomerInput;
+}>;
+
+
+export type UpdateCustomerMutation = { __typename?: 'Mutation', updateCustomer: { __typename?: 'Customer', id: string, name: string, email?: string | null, phone?: string | null, type: string, company?: string | null, address?: Record<string, unknown> | null, rating?: number | null, createdAt: string, updatedAt: string } };
+
+export type DeleteCustomerMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type DeleteCustomerMutation = { __typename?: 'Mutation', deleteCustomer: boolean };
+
+export type CreateProductMutationVariables = Types.Exact<{
+  input: Types.CreateProductInput;
+}>;
+
+
+export type CreateProductMutation = { __typename?: 'Mutation', createProduct: { __typename?: 'Product', id: string, sku: string, name: string, description?: string | null, category?: string | null, brand?: string | null, dimensions?: Record<string, unknown> | null, weight?: number | null, value?: number | null, hazardous: boolean, fragile: boolean, temperatureControlled: boolean, createdAt: string, updatedAt: string } };
+
+export type UpdateProductMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  input: Types.UpdateProductInput;
+}>;
+
+
+export type UpdateProductMutation = { __typename?: 'Mutation', updateProduct: { __typename?: 'Product', id: string, sku: string, name: string, description?: string | null, category?: string | null, brand?: string | null, dimensions?: Record<string, unknown> | null, weight?: number | null, value?: number | null, hazardous: boolean, fragile: boolean, temperatureControlled: boolean, createdAt: string, updatedAt: string } };
+
+export type DeleteProductMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type DeleteProductMutation = { __typename?: 'Mutation', deleteProduct: boolean };
+
+export type CreateVehicleMutationVariables = Types.Exact<{
+  input: Types.CreateVehicleInput;
+}>;
+
+
+export type CreateVehicleMutation = { __typename?: 'Mutation', createVehicle: { __typename?: 'Vehicle', id: string, vehicleNumber: string, make?: string | null, model?: string | null, year?: number | null, licensePlate?: string | null, type: Types.VehicleType, ownershipType?: string | null, capacity?: Record<string, unknown> | null, status: Types.VehicleStatus, currentLocation?: Record<string, unknown> | null, fuelLevel?: number | null, mileage?: number | null, createdAt: string, updatedAt: string } };
+
+export type UpdateVehicleMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  input: Types.UpdateVehicleInput;
+}>;
+
+
+export type UpdateVehicleMutation = { __typename?: 'Mutation', updateVehicle: { __typename?: 'Vehicle', id: string, vehicleNumber: string, make?: string | null, model?: string | null, year?: number | null, licensePlate?: string | null, type: Types.VehicleType, ownershipType?: string | null, capacity?: Record<string, unknown> | null, status: Types.VehicleStatus, currentLocation?: Record<string, unknown> | null, fuelLevel?: number | null, mileage?: number | null, createdAt: string, updatedAt: string } };
+
+export type UpdateVehicleStatusMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  status: Types.VehicleStatus;
+}>;
+
+
+export type UpdateVehicleStatusMutation = { __typename?: 'Mutation', updateVehicleStatus: { __typename?: 'Vehicle', id: string, vehicleNumber: string, make?: string | null, model?: string | null, year?: number | null, licensePlate?: string | null, type: Types.VehicleType, ownershipType?: string | null, capacity?: Record<string, unknown> | null, status: Types.VehicleStatus, currentLocation?: Record<string, unknown> | null, fuelLevel?: number | null, mileage?: number | null, createdAt: string, updatedAt: string } };
+
+export type UpdateVehicleLocationMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  location: Types.Scalars['JSON']['input'];
+}>;
+
+
+export type UpdateVehicleLocationMutation = { __typename?: 'Mutation', updateVehicleLocation: { __typename?: 'Vehicle', id: string, vehicleNumber: string, make?: string | null, model?: string | null, year?: number | null, licensePlate?: string | null, type: Types.VehicleType, ownershipType?: string | null, capacity?: Record<string, unknown> | null, status: Types.VehicleStatus, currentLocation?: Record<string, unknown> | null, fuelLevel?: number | null, mileage?: number | null, createdAt: string, updatedAt: string } };
+
+export type DeleteVehicleMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type DeleteVehicleMutation = { __typename?: 'Mutation', deleteVehicle: boolean };
+
+export type CreateDriverMutationVariables = Types.Exact<{
+  input: Types.CreateDriverInput;
+}>;
+
+
+export type CreateDriverMutation = { __typename?: 'Mutation', createDriver: { __typename?: 'Driver', id: string, employeeId: string, firstName: string, lastName: string, phone?: string | null, email?: string | null, licenseNumber?: string | null, licenseClass?: string | null, licenseExpiry?: string | null, status: Types.DriverStatus, currentLocation?: Record<string, unknown> | null, rating?: number | null, userId?: string | null, vehicleId?: string | null, createdAt: string, updatedAt: string } };
+
+export type UpdateDriverMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  input: Types.UpdateDriverInput;
+}>;
+
+
+export type UpdateDriverMutation = { __typename?: 'Mutation', updateDriver: { __typename?: 'Driver', id: string, employeeId: string, firstName: string, lastName: string, phone?: string | null, email?: string | null, licenseNumber?: string | null, licenseClass?: string | null, licenseExpiry?: string | null, status: Types.DriverStatus, currentLocation?: Record<string, unknown> | null, rating?: number | null, userId?: string | null, vehicleId?: string | null, createdAt: string, updatedAt: string } };
+
+export type UpdateDriverStatusMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  status: Types.DriverStatus;
+}>;
+
+
+export type UpdateDriverStatusMutation = { __typename?: 'Mutation', updateDriverStatus: { __typename?: 'Driver', id: string, employeeId: string, firstName: string, lastName: string, phone?: string | null, email?: string | null, licenseNumber?: string | null, licenseClass?: string | null, licenseExpiry?: string | null, status: Types.DriverStatus, currentLocation?: Record<string, unknown> | null, rating?: number | null, userId?: string | null, vehicleId?: string | null, createdAt: string, updatedAt: string } };
+
+export type AssignDriverVehicleMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  vehicleId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+}>;
+
+
+export type AssignDriverVehicleMutation = { __typename?: 'Mutation', assignDriverVehicle: { __typename?: 'Driver', id: string, employeeId: string, firstName: string, lastName: string, phone?: string | null, email?: string | null, licenseNumber?: string | null, licenseClass?: string | null, licenseExpiry?: string | null, status: Types.DriverStatus, currentLocation?: Record<string, unknown> | null, rating?: number | null, userId?: string | null, vehicleId?: string | null, createdAt: string, updatedAt: string } };
+
+export type DeleteDriverMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type DeleteDriverMutation = { __typename?: 'Mutation', deleteDriver: boolean };
+
+export type CreateWarehouseMutationVariables = Types.Exact<{
+  input: Types.CreateWarehouseInput;
+}>;
+
+
+export type CreateWarehouseMutation = { __typename?: 'Mutation', createWarehouse: { __typename?: 'Warehouse', id: string, name: string, code: string, type: Types.WarehouseType, address: Record<string, unknown>, contactInfo?: Record<string, unknown> | null, operatingHours?: Record<string, unknown> | null, capabilities?: Record<string, unknown> | null, status: string, totalCapacity?: number | null, usedCapacity?: number | null, createdAt: string, updatedAt: string } };
+
+export type UpdateWarehouseMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  input: Types.UpdateWarehouseInput;
+}>;
+
+
+export type UpdateWarehouseMutation = { __typename?: 'Mutation', updateWarehouse: { __typename?: 'Warehouse', id: string, name: string, code: string, type: Types.WarehouseType, address: Record<string, unknown>, contactInfo?: Record<string, unknown> | null, operatingHours?: Record<string, unknown> | null, capabilities?: Record<string, unknown> | null, status: string, totalCapacity?: number | null, usedCapacity?: number | null, createdAt: string, updatedAt: string } };
+
+export type DeleteWarehouseMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type DeleteWarehouseMutation = { __typename?: 'Mutation', deleteWarehouse: boolean };
+
+export type CreateInventoryItemMutationVariables = Types.Exact<{
+  input: Types.CreateInventoryItemInput;
+}>;
+
+
+export type CreateInventoryItemMutation = { __typename?: 'Mutation', createInventoryItem: { __typename?: 'InventoryItem', id: string, productId: string, warehouseId: string, locationId?: string | null, onHand: number, available: number, allocated: number, damaged: number, unitCost?: number | null, reorderPoint?: number | null, safetyStock?: number | null, createdAt: string, updatedAt: string } };
+
+export type UpdateInventoryItemMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  input: Types.UpdateInventoryItemInput;
+}>;
+
+
+export type UpdateInventoryItemMutation = { __typename?: 'Mutation', updateInventoryItem: { __typename?: 'InventoryItem', id: string, productId: string, warehouseId: string, locationId?: string | null, onHand: number, available: number, allocated: number, damaged: number, unitCost?: number | null, reorderPoint?: number | null, safetyStock?: number | null, createdAt: string, updatedAt: string } };
+
+export type AdjustInventoryStockMutationVariables = Types.Exact<{
+  input: Types.AdjustInventoryStockInput;
+}>;
+
+
+export type AdjustInventoryStockMutation = { __typename?: 'Mutation', adjustInventoryStock: { __typename?: 'InventoryItem', id: string, productId: string, warehouseId: string, locationId?: string | null, onHand: number, available: number, allocated: number, damaged: number, unitCost?: number | null, reorderPoint?: number | null, safetyStock?: number | null, createdAt: string, updatedAt: string } };
+
+export type DeleteInventoryItemMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type DeleteInventoryItemMutation = { __typename?: 'Mutation', deleteInventoryItem: boolean };
+
+export type CreateRouteMutationVariables = Types.Exact<{
+  input: Types.CreateRouteInput;
+}>;
+
+
+export type CreateRouteMutation = { __typename?: 'Mutation', createRoute: { __typename?: 'Route', id: string, name: string, status: Types.RouteStatus, shipmentId?: string | null, vehicleId?: string | null, driverId?: string | null, waypoints: Record<string, unknown>, estimatedDistance?: number | null, estimatedDuration?: number | null, actualDistance?: number | null, actualDuration?: number | null, fuelCost?: number | null, createdAt: string, updatedAt: string } };
+
+export type UpdateRouteMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  input: Types.UpdateRouteInput;
+}>;
+
+
+export type UpdateRouteMutation = { __typename?: 'Mutation', updateRoute: { __typename?: 'Route', id: string, name: string, status: Types.RouteStatus, shipmentId?: string | null, vehicleId?: string | null, driverId?: string | null, waypoints: Record<string, unknown>, estimatedDistance?: number | null, estimatedDuration?: number | null, actualDistance?: number | null, actualDuration?: number | null, fuelCost?: number | null, createdAt: string, updatedAt: string } };
+
+export type OptimizeRouteMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type OptimizeRouteMutation = { __typename?: 'Mutation', optimizeRoute: { __typename?: 'Route', id: string, name: string, status: Types.RouteStatus, shipmentId?: string | null, vehicleId?: string | null, driverId?: string | null, waypoints: Record<string, unknown>, estimatedDistance?: number | null, estimatedDuration?: number | null, actualDistance?: number | null, actualDuration?: number | null, fuelCost?: number | null, createdAt: string, updatedAt: string } };
+
+export type DeleteRouteMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type DeleteRouteMutation = { __typename?: 'Mutation', deleteRoute: boolean };
+
+export type CreateShipmentMutationVariables = Types.Exact<{
+  input: Types.CreateShipmentInput;
+}>;
+
+
+export type CreateShipmentMutation = { __typename?: 'Mutation', createShipment: { __typename?: 'Shipment', id: string, shipmentNumber: string, orderId: string, customerId?: string | null, carrierId?: string | null, status: Types.ShipmentStatus, origin: Record<string, unknown>, destination: Record<string, unknown>, cargoDetails?: Record<string, unknown> | null, trackingNumber?: string | null, estimatedDelivery?: string | null, actualDelivery?: string | null, createdAt: string, updatedAt: string } };
+
+export type UpdateShipmentMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  input: Types.UpdateShipmentInput;
+}>;
+
+
+export type UpdateShipmentMutation = { __typename?: 'Mutation', updateShipment: { __typename?: 'Shipment', id: string, shipmentNumber: string, orderId: string, customerId?: string | null, carrierId?: string | null, status: Types.ShipmentStatus, origin: Record<string, unknown>, destination: Record<string, unknown>, cargoDetails?: Record<string, unknown> | null, trackingNumber?: string | null, estimatedDelivery?: string | null, actualDelivery?: string | null, createdAt: string, updatedAt: string } };
+
+export type DeleteShipmentMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type DeleteShipmentMutation = { __typename?: 'Mutation', deleteShipment: boolean };
+
+export type AddTrackingEventMutationVariables = Types.Exact<{
+  input: Types.AddTrackingEventInput;
+}>;
+
+
+export type AddTrackingEventMutation = { __typename?: 'Mutation', addTrackingEvent: { __typename?: 'TrackingEvent', id: string, shipmentId: string, eventType: Types.TrackingEventType, location?: Record<string, unknown> | null, details?: string | null, timestamp: string } };
+
+export type CreateServiceProviderMutationVariables = Types.Exact<{
+  input: Types.CreateServiceProviderInput;
+}>;
+
+
+export type CreateServiceProviderMutation = { __typename?: 'Mutation', createServiceProvider: { __typename?: 'ServiceProvider', id: string, name: string, type: string, description?: string | null, rating?: number | null, contactInfo?: Record<string, unknown> | null, services?: Record<string, unknown> | null, isVerified: boolean, isActive: boolean, createdAt: string, updatedAt: string } };
+
+export type UpdateServiceProviderMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  input: Types.UpdateServiceProviderInput;
+}>;
+
+
+export type UpdateServiceProviderMutation = { __typename?: 'Mutation', updateServiceProvider: { __typename?: 'ServiceProvider', id: string, name: string, type: string, description?: string | null, rating?: number | null, contactInfo?: Record<string, unknown> | null, services?: Record<string, unknown> | null, isVerified: boolean, isActive: boolean, createdAt: string, updatedAt: string } };
+
+export type DeleteServiceProviderMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type DeleteServiceProviderMutation = { __typename?: 'Mutation', deleteServiceProvider: boolean };
+
+export type CreateServiceOfferingMutationVariables = Types.Exact<{
+  input: Types.CreateServiceOfferingInput;
+}>;
+
+
+export type CreateServiceOfferingMutation = { __typename?: 'Mutation', createServiceOffering: { __typename?: 'ServiceOffering', id: string, providerId: string, name: string, description?: string | null, category?: string | null, price: number, currency: string, availability?: Record<string, unknown> | null, createdAt: string, updatedAt: string } };
+
+export type UpdateServiceOfferingMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  input: Types.UpdateServiceOfferingInput;
+}>;
+
+
+export type UpdateServiceOfferingMutation = { __typename?: 'Mutation', updateServiceOffering: { __typename?: 'ServiceOffering', id: string, providerId: string, name: string, description?: string | null, category?: string | null, price: number, currency: string, availability?: Record<string, unknown> | null, createdAt: string, updatedAt: string } };
+
+export type DeleteServiceOfferingMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type DeleteServiceOfferingMutation = { __typename?: 'Mutation', deleteServiceOffering: boolean };
+
+export type CreateMovethewheelsReportMutationVariables = Types.Exact<{
+  input: Types.CreateMovethewheelsReportInput;
+}>;
+
+
+export type CreateMovethewheelsReportMutation = { __typename?: 'Mutation', createMovethewheelsReport: { __typename?: 'MovethewheelsReport', id: string, name: string, type: string, description?: string | null, schedule?: string | null, lastGenerated?: string | null, configuration?: Record<string, unknown> | null, status: string, createdAt: string, updatedAt: string } };
+
+export type UpdateMovethewheelsReportMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  input: Types.UpdateMovethewheelsReportInput;
+}>;
+
+
+export type UpdateMovethewheelsReportMutation = { __typename?: 'Mutation', updateMovethewheelsReport: { __typename?: 'MovethewheelsReport', id: string, name: string, type: string, description?: string | null, schedule?: string | null, lastGenerated?: string | null, configuration?: Record<string, unknown> | null, status: string, createdAt: string, updatedAt: string } };
+
+export type DeleteMovethewheelsReportMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type DeleteMovethewheelsReportMutation = { __typename?: 'Mutation', deleteMovethewheelsReport: boolean };
+
+export type GenerateMovethewheelsReportMutationVariables = Types.Exact<{
+  input: Types.GenerateMovethewheelsReportInput;
+}>;
+
+
+export type GenerateMovethewheelsReportMutation = { __typename?: 'Mutation', generateMovethewheelsReport: { __typename?: 'GeneratedReport', generatedAt: string, result?: Record<string, unknown> | null, report: { __typename?: 'MovethewheelsReport', id: string, name: string, type: string, description?: string | null, schedule?: string | null, lastGenerated?: string | null, configuration?: Record<string, unknown> | null, status: string, createdAt: string, updatedAt: string } } };
+
+export type ImportMovethewheelsDataMutationVariables = Types.Exact<{
+  input: Types.MovethewheelsImportDataInput;
+}>;
+
+
+export type ImportMovethewheelsDataMutation = { __typename?: 'Mutation', importData: { __typename?: 'ImportExportResult', success: boolean, message: string, payload?: Record<string, unknown> | null } };
+
+export type ExportMovethewheelsDataMutationVariables = Types.Exact<{
+  input: Types.MovethewheelsExportDataInput;
+}>;
+
+
+export type ExportMovethewheelsDataMutation = { __typename?: 'Mutation', exportData: { __typename?: 'ImportExportResult', success: boolean, message: string, payload?: Record<string, unknown> | null } };
+
+export type UpdateMovethewheelsModuleSettingsMutationVariables = Types.Exact<{
+  input: Types.UpdateMovethewheelsModuleSettingsInput;
+}>;
+
+
+export type UpdateMovethewheelsModuleSettingsMutation = { __typename?: 'Mutation', updateModuleSettings: { __typename?: 'ModuleSettings', workspaceId: string, preferences: Record<string, unknown>, updatedAt: string } };
+
+export type CreateMovethewheelsOrderMutationVariables = Types.Exact<{
+  input: Types.CreateOrderInput;
+}>;
+
+
+export type CreateMovethewheelsOrderMutation = { __typename?: 'Mutation', createMovethewheelsOrder: { __typename?: 'MovethewheelsOrder', id: string, orderNumber: string, orderType: Types.OrderType, status: Types.OrderStatus, priority: Types.OrderPriority, customerId: string, trackingNumber?: string | null, pickupAddress: Record<string, unknown>, deliveryAddress: Record<string, unknown>, items: Record<string, unknown>, pricing?: Record<string, unknown> | null, scheduledDelivery?: string | null, vehicleId?: string | null, driverId?: string | null, createdAt: string, updatedAt: string } };
+
+export type UpdateMovethewheelsOrderMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  input: Types.UpdateOrderInput;
+}>;
+
+
+export type UpdateMovethewheelsOrderMutation = { __typename?: 'Mutation', updateMovethewheelsOrder: { __typename?: 'MovethewheelsOrder', id: string, orderNumber: string, orderType: Types.OrderType, status: Types.OrderStatus, priority: Types.OrderPriority, customerId: string, trackingNumber?: string | null, pickupAddress: Record<string, unknown>, deliveryAddress: Record<string, unknown>, items: Record<string, unknown>, pricing?: Record<string, unknown> | null, scheduledDelivery?: string | null, vehicleId?: string | null, driverId?: string | null, createdAt: string, updatedAt: string } };
+
+export type UpdateMovethewheelsOrderStatusMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+  input: Types.UpdateOrderStatusInput;
+}>;
+
+
+export type UpdateMovethewheelsOrderStatusMutation = { __typename?: 'Mutation', updateMovethewheelsOrderStatus: { __typename?: 'MovethewheelsOrder', id: string, orderNumber: string, orderType: Types.OrderType, status: Types.OrderStatus, priority: Types.OrderPriority, customerId: string, trackingNumber?: string | null, pickupAddress: Record<string, unknown>, deliveryAddress: Record<string, unknown>, items: Record<string, unknown>, pricing?: Record<string, unknown> | null, scheduledDelivery?: string | null, vehicleId?: string | null, driverId?: string | null, createdAt: string, updatedAt: string } };
+
+export type DeleteMovethewheelsOrderMutationVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type DeleteMovethewheelsOrderMutation = { __typename?: 'Mutation', deleteMovethewheelsOrder: boolean };
+
+export type GetMovethewheelsDashboardQueryVariables = Types.Exact<{ [key: string]: never; }>;
+
+
+export type GetMovethewheelsDashboardQuery = { __typename?: 'Query', dashboardMetrics: { __typename?: 'DashboardMetrics', totalOrders: number, activeDeliveries: number, availableDrivers: number, activeVehicles: number, lowStockItems: number, totalRevenue: number, recentOrders: Array<{ __typename?: 'MovethewheelsOrder', id: string, orderNumber: string, orderType: Types.OrderType, status: Types.OrderStatus, priority: Types.OrderPriority, customerId: string, trackingNumber?: string | null, pickupAddress: Record<string, unknown>, deliveryAddress: Record<string, unknown>, items: Record<string, unknown>, pricing?: Record<string, unknown> | null, scheduledDelivery?: string | null, vehicleId?: string | null, driverId?: string | null, createdAt: string, updatedAt: string }> }, orderStats: { __typename?: 'OrderStats', total: number, pending: number, inTransit: number, delivered: number, cancelled: number, failed: number }, fleetStats: { __typename?: 'FleetStats', totalVehicles: number, activeVehicles: number, inTransitVehicles: number, maintenanceVehicles: number, totalDrivers: number, availableDrivers: number, onDeliveryDrivers: number }, financeMetrics: { __typename?: 'FinanceMetrics', fuelCost: number, openInvoices: number, revenue: { __typename?: 'RevenueMetrics', totalRevenue: number, averageOrderValue: number, deliveredRevenue: number } }, analytics: { __typename?: 'AnalyticsSeries', deliveryTrend: Array<{ __typename?: 'AnalyticsPoint', label: string, value: number }>, orderTrend: Array<{ __typename?: 'AnalyticsPoint', label: string, value: number }>, revenueTrend: Array<{ __typename?: 'AnalyticsPoint', label: string, value: number }> } };
+
+export type GetAssistantInsightsQueryVariables = Types.Exact<{
+  question: Types.Scalars['String']['input'];
+}>;
+
+
+export type GetAssistantInsightsQuery = { __typename?: 'Query', assistantInsights: { __typename?: 'AssistantInsights', question: string, answer: string, generatedAt: string } };
+
+export type ListCustomersQueryVariables = Types.Exact<{
+  filter?: Types.InputMaybe<Types.CustomerFilterInput>;
+  pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+
+
+export type ListCustomersQuery = { __typename?: 'Query', customers: Array<{ __typename?: 'Customer', id: string, name: string, email?: string | null, phone?: string | null, type: string, company?: string | null, address?: Record<string, unknown> | null, rating?: number | null, createdAt: string, updatedAt: string }> };
+
+export type GetCustomerQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type GetCustomerQuery = { __typename?: 'Query', customer?: { __typename?: 'Customer', id: string, name: string, email?: string | null, phone?: string | null, type: string, company?: string | null, address?: Record<string, unknown> | null, rating?: number | null, createdAt: string, updatedAt: string } | null };
+
+export type ListProductsQueryVariables = Types.Exact<{
+  filter?: Types.InputMaybe<Types.ProductFilterInput>;
+  pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+
+
+export type ListProductsQuery = { __typename?: 'Query', products: Array<{ __typename?: 'Product', id: string, sku: string, name: string, description?: string | null, category?: string | null, brand?: string | null, dimensions?: Record<string, unknown> | null, weight?: number | null, value?: number | null, hazardous: boolean, fragile: boolean, temperatureControlled: boolean, createdAt: string, updatedAt: string }> };
+
+export type GetProductQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type GetProductQuery = { __typename?: 'Query', product?: { __typename?: 'Product', id: string, sku: string, name: string, description?: string | null, category?: string | null, brand?: string | null, dimensions?: Record<string, unknown> | null, weight?: number | null, value?: number | null, hazardous: boolean, fragile: boolean, temperatureControlled: boolean, createdAt: string, updatedAt: string } | null };
+
+export type ListVehiclesQueryVariables = Types.Exact<{
+  filter?: Types.InputMaybe<Types.VehicleFilterInput>;
+  pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+
+
+export type ListVehiclesQuery = { __typename?: 'Query', vehicles: Array<{ __typename?: 'Vehicle', id: string, vehicleNumber: string, make?: string | null, model?: string | null, year?: number | null, licensePlate?: string | null, type: Types.VehicleType, ownershipType?: string | null, capacity?: Record<string, unknown> | null, status: Types.VehicleStatus, currentLocation?: Record<string, unknown> | null, fuelLevel?: number | null, mileage?: number | null, createdAt: string, updatedAt: string }> };
+
+export type GetVehicleQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type GetVehicleQuery = { __typename?: 'Query', vehicle?: { __typename?: 'Vehicle', id: string, vehicleNumber: string, make?: string | null, model?: string | null, year?: number | null, licensePlate?: string | null, type: Types.VehicleType, ownershipType?: string | null, capacity?: Record<string, unknown> | null, status: Types.VehicleStatus, currentLocation?: Record<string, unknown> | null, fuelLevel?: number | null, mileage?: number | null, createdAt: string, updatedAt: string } | null };
+
+export type ListDriversQueryVariables = Types.Exact<{
+  filter?: Types.InputMaybe<Types.DriverFilterInput>;
+  pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+
+
+export type ListDriversQuery = { __typename?: 'Query', drivers: Array<{ __typename?: 'Driver', id: string, employeeId: string, firstName: string, lastName: string, phone?: string | null, email?: string | null, licenseNumber?: string | null, licenseClass?: string | null, licenseExpiry?: string | null, status: Types.DriverStatus, currentLocation?: Record<string, unknown> | null, rating?: number | null, userId?: string | null, vehicleId?: string | null, createdAt: string, updatedAt: string }> };
+
+export type GetDriverQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type GetDriverQuery = { __typename?: 'Query', driver?: { __typename?: 'Driver', id: string, employeeId: string, firstName: string, lastName: string, phone?: string | null, email?: string | null, licenseNumber?: string | null, licenseClass?: string | null, licenseExpiry?: string | null, status: Types.DriverStatus, currentLocation?: Record<string, unknown> | null, rating?: number | null, userId?: string | null, vehicleId?: string | null, createdAt: string, updatedAt: string } | null };
+
+export type ListWarehousesQueryVariables = Types.Exact<{
+  filter?: Types.InputMaybe<Types.WarehouseFilterInput>;
+  pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+
+
+export type ListWarehousesQuery = { __typename?: 'Query', warehouses: Array<{ __typename?: 'Warehouse', id: string, name: string, code: string, type: Types.WarehouseType, address: Record<string, unknown>, contactInfo?: Record<string, unknown> | null, operatingHours?: Record<string, unknown> | null, capabilities?: Record<string, unknown> | null, status: string, totalCapacity?: number | null, usedCapacity?: number | null, createdAt: string, updatedAt: string, locations: Array<{ __typename?: 'WarehouseLocation', id: string, locationCode: string, zone?: string | null, aisle?: string | null, rack?: string | null, shelf?: string | null, bin?: string | null, locationType?: string | null, capacity?: number | null, status: string }> }> };
+
+export type GetWarehouseQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type GetWarehouseQuery = { __typename?: 'Query', warehouse?: { __typename?: 'Warehouse', id: string, name: string, code: string, type: Types.WarehouseType, address: Record<string, unknown>, contactInfo?: Record<string, unknown> | null, operatingHours?: Record<string, unknown> | null, capabilities?: Record<string, unknown> | null, status: string, totalCapacity?: number | null, usedCapacity?: number | null, createdAt: string, updatedAt: string, locations: Array<{ __typename?: 'WarehouseLocation', id: string, locationCode: string, zone?: string | null, aisle?: string | null, rack?: string | null, shelf?: string | null, bin?: string | null, locationType?: string | null, capacity?: number | null, status: string }> } | null };
+
+export type ListInventoryItemsQueryVariables = Types.Exact<{
+  filter?: Types.InputMaybe<Types.InventoryFilterInput>;
+  pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+
+
+export type ListInventoryItemsQuery = { __typename?: 'Query', inventoryItems: Array<{ __typename?: 'InventoryItem', id: string, productId: string, warehouseId: string, locationId?: string | null, onHand: number, available: number, allocated: number, damaged: number, unitCost?: number | null, reorderPoint?: number | null, safetyStock?: number | null, createdAt: string, updatedAt: string, product?: { __typename?: 'Product', id: string, name: string, sku: string, category?: string | null } | null, warehouse?: { __typename?: 'Warehouse', id: string, name: string, code: string, type: Types.WarehouseType } | null }> };
+
+export type GetInventoryStatsQueryVariables = Types.Exact<{ [key: string]: never; }>;
+
+
+export type GetInventoryStatsQuery = { __typename?: 'Query', inventoryStats: { __typename?: 'InventoryStats', totalOnHand: number, totalAvailable: number, totalAllocated: number, totalDamaged: number, lowStockCount: number } };
+
+export type ListRoutesQueryVariables = Types.Exact<{
+  filter?: Types.InputMaybe<Types.RouteFilterInput>;
+  pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+
+
+export type ListRoutesQuery = { __typename?: 'Query', routes: Array<{ __typename?: 'Route', id: string, name: string, status: Types.RouteStatus, shipmentId?: string | null, vehicleId?: string | null, driverId?: string | null, waypoints: Record<string, unknown>, estimatedDistance?: number | null, estimatedDuration?: number | null, actualDistance?: number | null, actualDuration?: number | null, fuelCost?: number | null, createdAt: string, updatedAt: string }> };
+
+export type GetRouteQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type GetRouteQuery = { __typename?: 'Query', route?: { __typename?: 'Route', id: string, name: string, status: Types.RouteStatus, shipmentId?: string | null, vehicleId?: string | null, driverId?: string | null, waypoints: Record<string, unknown>, estimatedDistance?: number | null, estimatedDuration?: number | null, actualDistance?: number | null, actualDuration?: number | null, fuelCost?: number | null, createdAt: string, updatedAt: string } | null };
+
+export type ListShipmentsQueryVariables = Types.Exact<{
+  filter?: Types.InputMaybe<Types.ShipmentFilterInput>;
+  pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+
+
+export type ListShipmentsQuery = { __typename?: 'Query', shipments: Array<{ __typename?: 'Shipment', id: string, shipmentNumber: string, orderId: string, customerId?: string | null, carrierId?: string | null, status: Types.ShipmentStatus, origin: Record<string, unknown>, destination: Record<string, unknown>, cargoDetails?: Record<string, unknown> | null, trackingNumber?: string | null, estimatedDelivery?: string | null, actualDelivery?: string | null, createdAt: string, updatedAt: string }> };
+
+export type GetShipmentQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type GetShipmentQuery = { __typename?: 'Query', shipment?: { __typename?: 'Shipment', id: string, shipmentNumber: string, orderId: string, customerId?: string | null, carrierId?: string | null, status: Types.ShipmentStatus, origin: Record<string, unknown>, destination: Record<string, unknown>, cargoDetails?: Record<string, unknown> | null, trackingNumber?: string | null, estimatedDelivery?: string | null, actualDelivery?: string | null, createdAt: string, updatedAt: string, trackingEvents: Array<{ __typename?: 'TrackingEvent', id: string, eventType: Types.TrackingEventType, location?: Record<string, unknown> | null, details?: string | null, timestamp: string }> } | null };
+
+export type GetOrderTrackingQueryVariables = Types.Exact<{
+  orderId: Types.Scalars['ID']['input'];
+}>;
+
+
+export type GetOrderTrackingQuery = { __typename?: 'Query', orderTracking: Array<{ __typename?: 'TrackingEvent', id: string, shipmentId: string, eventType: Types.TrackingEventType, location?: Record<string, unknown> | null, details?: string | null, timestamp: string }> };
+
+export type GetActiveDeliveriesQueryVariables = Types.Exact<{ [key: string]: never; }>;
+
+
+export type GetActiveDeliveriesQuery = { __typename?: 'Query', activeDeliveries: Array<{ __typename?: 'Shipment', id: string, shipmentNumber: string, orderId: string, customerId?: string | null, carrierId?: string | null, status: Types.ShipmentStatus, origin: Record<string, unknown>, destination: Record<string, unknown>, cargoDetails?: Record<string, unknown> | null, trackingNumber?: string | null, estimatedDelivery?: string | null, actualDelivery?: string | null, createdAt: string, updatedAt: string }> };
+
+export type GetTrackingAlertsQueryVariables = Types.Exact<{ [key: string]: never; }>;
+
+
+export type GetTrackingAlertsQuery = { __typename?: 'Query', trackingAlerts: Array<{ __typename?: 'TrackingAlert', shipmentId: string, shipmentNumber: string, alertType: string, message: string }> };
+
+export type ListServiceProvidersQueryVariables = Types.Exact<{
+  filter?: Types.InputMaybe<Types.ServiceProviderFilterInput>;
+  pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+
+
+export type ListServiceProvidersQuery = { __typename?: 'Query', serviceProviders: Array<{ __typename?: 'ServiceProvider', id: string, name: string, type: string, description?: string | null, rating?: number | null, contactInfo?: Record<string, unknown> | null, services?: Record<string, unknown> | null, isVerified: boolean, isActive: boolean, createdAt: string, updatedAt: string }> };
+
+export type ListServiceOfferingsQueryVariables = Types.Exact<{
+  filter?: Types.InputMaybe<Types.ServiceOfferingFilterInput>;
+  pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+
+
+export type ListServiceOfferingsQuery = { __typename?: 'Query', serviceOfferings: Array<{ __typename?: 'ServiceOffering', id: string, providerId: string, name: string, description?: string | null, category?: string | null, price: number, currency: string, availability?: Record<string, unknown> | null, createdAt: string, updatedAt: string, provider?: { __typename?: 'ServiceProvider', id: string, name: string, type: string, rating?: number | null } | null }> };
+
+export type ListMovethewheelsReportsQueryVariables = Types.Exact<{
+  filter?: Types.InputMaybe<Types.MovethewheelsReportFilterInput>;
+  pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+
+
+export type ListMovethewheelsReportsQuery = { __typename?: 'Query', movethewheelsReports: Array<{ __typename?: 'MovethewheelsReport', id: string, name: string, type: string, description?: string | null, schedule?: string | null, lastGenerated?: string | null, configuration?: Record<string, unknown> | null, status: string, createdAt: string, updatedAt: string }> };
+
+export type GetMovethewheelsReportQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type GetMovethewheelsReportQuery = { __typename?: 'Query', movethewheelsReport?: { __typename?: 'MovethewheelsReport', id: string, name: string, type: string, description?: string | null, schedule?: string | null, lastGenerated?: string | null, configuration?: Record<string, unknown> | null, status: string, createdAt: string, updatedAt: string } | null };
+
+export type GetMovethewheelsModuleSettingsQueryVariables = Types.Exact<{ [key: string]: never; }>;
+
+
+export type GetMovethewheelsModuleSettingsQuery = { __typename?: 'Query', moduleSettings: { __typename?: 'ModuleSettings', workspaceId: string, preferences: Record<string, unknown>, updatedAt: string } };
+
+export type ListMovethewheelsOrdersQueryVariables = Types.Exact<{
+  filter?: Types.InputMaybe<Types.OrderFilterInput>;
+  pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+
+
+export type ListMovethewheelsOrdersQuery = { __typename?: 'Query', movethewheelsOrders: Array<{ __typename?: 'MovethewheelsOrder', id: string, orderNumber: string, orderType: Types.OrderType, status: Types.OrderStatus, priority: Types.OrderPriority, customerId: string, trackingNumber?: string | null, pickupAddress: Record<string, unknown>, deliveryAddress: Record<string, unknown>, items: Record<string, unknown>, pricing?: Record<string, unknown> | null, scheduledDelivery?: string | null, vehicleId?: string | null, driverId?: string | null, createdAt: string, updatedAt: string }> };
+
+export type GetMovethewheelsOrderQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID']['input'];
+}>;
+
+
+export type GetMovethewheelsOrderQuery = { __typename?: 'Query', movethewheelsOrder?: { __typename?: 'MovethewheelsOrder', id: string, orderNumber: string, orderType: Types.OrderType, status: Types.OrderStatus, priority: Types.OrderPriority, customerId: string, trackingNumber?: string | null, pickupAddress: Record<string, unknown>, deliveryAddress: Record<string, unknown>, items: Record<string, unknown>, pricing?: Record<string, unknown> | null, scheduledDelivery?: string | null, vehicleId?: string | null, driverId?: string | null, createdAt: string, updatedAt: string, customer?: { __typename?: 'Customer', id: string, name: string, email?: string | null, phone?: string | null } | null, vehicle?: { __typename?: 'Vehicle', id: string, vehicleNumber: string, type: Types.VehicleType, status: Types.VehicleStatus } | null, driver?: { __typename?: 'Driver', id: string, firstName: string, lastName: string, status: Types.DriverStatus } | null, statusHistory: Array<{ __typename?: 'OrderStatusHistory', id: string, status: Types.OrderStatus, previousStatus?: Types.OrderStatus | null, notes?: string | null, location?: Record<string, unknown> | null, createdAt: string }>, shipment?: { __typename?: 'Shipment', id: string, shipmentNumber: string, status: Types.ShipmentStatus, trackingNumber?: string | null } | null } | null };
+
+export const MovethewheelsOrderCoreFragmentDoc = gql`
+    fragment MovethewheelsOrderCore on MovethewheelsOrder {
+  id
+  orderNumber
+  orderType
+  status
+  priority
+  customerId
+  trackingNumber
+  pickupAddress
+  deliveryAddress
+  items
+  pricing
+  scheduledDelivery
+  vehicleId
+  driverId
+  createdAt
+  updatedAt
+}
+    `;
+export const CustomerCoreFragmentDoc = gql`
+    fragment CustomerCore on Customer {
+  id
+  name
+  email
+  phone
+  type
+  company
+  address
+  rating
+  createdAt
+  updatedAt
+}
+    `;
+export const ProductCoreFragmentDoc = gql`
+    fragment ProductCore on Product {
+  id
+  sku
+  name
+  description
+  category
+  brand
+  dimensions
+  weight
+  value
+  hazardous
+  fragile
+  temperatureControlled
+  createdAt
+  updatedAt
+}
+    `;
+export const VehicleCoreFragmentDoc = gql`
+    fragment VehicleCore on Vehicle {
+  id
+  vehicleNumber
+  make
+  model
+  year
+  licensePlate
+  type
+  ownershipType
+  capacity
+  status
+  currentLocation
+  fuelLevel
+  mileage
+  createdAt
+  updatedAt
+}
+    `;
+export const DriverCoreFragmentDoc = gql`
+    fragment DriverCore on Driver {
+  id
+  employeeId
+  firstName
+  lastName
+  phone
+  email
+  licenseNumber
+  licenseClass
+  licenseExpiry
+  status
+  currentLocation
+  rating
+  userId
+  vehicleId
+  createdAt
+  updatedAt
+}
+    `;
+export const WarehouseCoreFragmentDoc = gql`
+    fragment WarehouseCore on Warehouse {
+  id
+  name
+  code
+  type
+  address
+  contactInfo
+  operatingHours
+  capabilities
+  status
+  totalCapacity
+  usedCapacity
+  createdAt
+  updatedAt
+}
+    `;
+export const InventoryItemCoreFragmentDoc = gql`
+    fragment InventoryItemCore on InventoryItem {
+  id
+  productId
+  warehouseId
+  locationId
+  onHand
+  available
+  allocated
+  damaged
+  unitCost
+  reorderPoint
+  safetyStock
+  createdAt
+  updatedAt
+}
+    `;
+export const RouteCoreFragmentDoc = gql`
+    fragment RouteCore on Route {
+  id
+  name
+  status
+  shipmentId
+  vehicleId
+  driverId
+  waypoints
+  estimatedDistance
+  estimatedDuration
+  actualDistance
+  actualDuration
+  fuelCost
+  createdAt
+  updatedAt
+}
+    `;
+export const ShipmentCoreFragmentDoc = gql`
+    fragment ShipmentCore on Shipment {
+  id
+  shipmentNumber
+  orderId
+  customerId
+  carrierId
+  status
+  origin
+  destination
+  cargoDetails
+  trackingNumber
+  estimatedDelivery
+  actualDelivery
+  createdAt
+  updatedAt
+}
+    `;
+export const ServiceProviderCoreFragmentDoc = gql`
+    fragment ServiceProviderCore on ServiceProvider {
+  id
+  name
+  type
+  description
+  rating
+  contactInfo
+  services
+  isVerified
+  isActive
+  createdAt
+  updatedAt
+}
+    `;
+export const ServiceOfferingCoreFragmentDoc = gql`
+    fragment ServiceOfferingCore on ServiceOffering {
+  id
+  providerId
+  name
+  description
+  category
+  price
+  currency
+  availability
+  createdAt
+  updatedAt
+}
+    `;
+export const MovethewheelsReportCoreFragmentDoc = gql`
+    fragment MovethewheelsReportCore on MovethewheelsReport {
+  id
+  name
+  type
+  description
+  schedule
+  lastGenerated
+  configuration
+  status
+  createdAt
+  updatedAt
+}
+    `;
+export const CreateCustomerDocument = gql`
+    mutation CreateCustomer($input: CreateCustomerInput!) {
+  createCustomer(input: $input) {
+    ...CustomerCore
+  }
+}
+    ${CustomerCoreFragmentDoc}`;
+export type CreateCustomerMutationFn = Apollo.MutationFunction<Types.CreateCustomerMutation, Types.CreateCustomerMutationVariables>;
+
+/**
+ * __useCreateCustomerMutation__
+ *
+ * To run a mutation, you first call `useCreateCustomerMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateCustomerMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createCustomerMutation, { data, loading, error }] = useCreateCustomerMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateCustomerMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateCustomerMutation, Types.CreateCustomerMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.CreateCustomerMutation, Types.CreateCustomerMutationVariables>(CreateCustomerDocument, options);
+      }
+export type CreateCustomerMutationHookResult = ReturnType<typeof useCreateCustomerMutation>;
+export type CreateCustomerMutationResult = Apollo.MutationResult<Types.CreateCustomerMutation>;
+export type CreateCustomerMutationOptions = Apollo.BaseMutationOptions<Types.CreateCustomerMutation, Types.CreateCustomerMutationVariables>;
+export const UpdateCustomerDocument = gql`
+    mutation UpdateCustomer($id: ID!, $input: UpdateCustomerInput!) {
+  updateCustomer(id: $id, input: $input) {
+    ...CustomerCore
+  }
+}
+    ${CustomerCoreFragmentDoc}`;
+export type UpdateCustomerMutationFn = Apollo.MutationFunction<Types.UpdateCustomerMutation, Types.UpdateCustomerMutationVariables>;
+
+/**
+ * __useUpdateCustomerMutation__
+ *
+ * To run a mutation, you first call `useUpdateCustomerMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateCustomerMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateCustomerMutation, { data, loading, error }] = useUpdateCustomerMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateCustomerMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateCustomerMutation, Types.UpdateCustomerMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateCustomerMutation, Types.UpdateCustomerMutationVariables>(UpdateCustomerDocument, options);
+      }
+export type UpdateCustomerMutationHookResult = ReturnType<typeof useUpdateCustomerMutation>;
+export type UpdateCustomerMutationResult = Apollo.MutationResult<Types.UpdateCustomerMutation>;
+export type UpdateCustomerMutationOptions = Apollo.BaseMutationOptions<Types.UpdateCustomerMutation, Types.UpdateCustomerMutationVariables>;
+export const DeleteCustomerDocument = gql`
+    mutation DeleteCustomer($id: ID!) {
+  deleteCustomer(id: $id)
+}
+    `;
+export type DeleteCustomerMutationFn = Apollo.MutationFunction<Types.DeleteCustomerMutation, Types.DeleteCustomerMutationVariables>;
+
+/**
+ * __useDeleteCustomerMutation__
+ *
+ * To run a mutation, you first call `useDeleteCustomerMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteCustomerMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteCustomerMutation, { data, loading, error }] = useDeleteCustomerMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteCustomerMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteCustomerMutation, Types.DeleteCustomerMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.DeleteCustomerMutation, Types.DeleteCustomerMutationVariables>(DeleteCustomerDocument, options);
+      }
+export type DeleteCustomerMutationHookResult = ReturnType<typeof useDeleteCustomerMutation>;
+export type DeleteCustomerMutationResult = Apollo.MutationResult<Types.DeleteCustomerMutation>;
+export type DeleteCustomerMutationOptions = Apollo.BaseMutationOptions<Types.DeleteCustomerMutation, Types.DeleteCustomerMutationVariables>;
+export const CreateProductDocument = gql`
+    mutation CreateProduct($input: CreateProductInput!) {
+  createProduct(input: $input) {
+    ...ProductCore
+  }
+}
+    ${ProductCoreFragmentDoc}`;
+export type CreateProductMutationFn = Apollo.MutationFunction<Types.CreateProductMutation, Types.CreateProductMutationVariables>;
+
+/**
+ * __useCreateProductMutation__
+ *
+ * To run a mutation, you first call `useCreateProductMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateProductMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createProductMutation, { data, loading, error }] = useCreateProductMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateProductMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateProductMutation, Types.CreateProductMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.CreateProductMutation, Types.CreateProductMutationVariables>(CreateProductDocument, options);
+      }
+export type CreateProductMutationHookResult = ReturnType<typeof useCreateProductMutation>;
+export type CreateProductMutationResult = Apollo.MutationResult<Types.CreateProductMutation>;
+export type CreateProductMutationOptions = Apollo.BaseMutationOptions<Types.CreateProductMutation, Types.CreateProductMutationVariables>;
+export const UpdateProductDocument = gql`
+    mutation UpdateProduct($id: ID!, $input: UpdateProductInput!) {
+  updateProduct(id: $id, input: $input) {
+    ...ProductCore
+  }
+}
+    ${ProductCoreFragmentDoc}`;
+export type UpdateProductMutationFn = Apollo.MutationFunction<Types.UpdateProductMutation, Types.UpdateProductMutationVariables>;
+
+/**
+ * __useUpdateProductMutation__
+ *
+ * To run a mutation, you first call `useUpdateProductMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateProductMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateProductMutation, { data, loading, error }] = useUpdateProductMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateProductMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateProductMutation, Types.UpdateProductMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateProductMutation, Types.UpdateProductMutationVariables>(UpdateProductDocument, options);
+      }
+export type UpdateProductMutationHookResult = ReturnType<typeof useUpdateProductMutation>;
+export type UpdateProductMutationResult = Apollo.MutationResult<Types.UpdateProductMutation>;
+export type UpdateProductMutationOptions = Apollo.BaseMutationOptions<Types.UpdateProductMutation, Types.UpdateProductMutationVariables>;
+export const DeleteProductDocument = gql`
+    mutation DeleteProduct($id: ID!) {
+  deleteProduct(id: $id)
+}
+    `;
+export type DeleteProductMutationFn = Apollo.MutationFunction<Types.DeleteProductMutation, Types.DeleteProductMutationVariables>;
+
+/**
+ * __useDeleteProductMutation__
+ *
+ * To run a mutation, you first call `useDeleteProductMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteProductMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteProductMutation, { data, loading, error }] = useDeleteProductMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteProductMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteProductMutation, Types.DeleteProductMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.DeleteProductMutation, Types.DeleteProductMutationVariables>(DeleteProductDocument, options);
+      }
+export type DeleteProductMutationHookResult = ReturnType<typeof useDeleteProductMutation>;
+export type DeleteProductMutationResult = Apollo.MutationResult<Types.DeleteProductMutation>;
+export type DeleteProductMutationOptions = Apollo.BaseMutationOptions<Types.DeleteProductMutation, Types.DeleteProductMutationVariables>;
+export const CreateVehicleDocument = gql`
+    mutation CreateVehicle($input: CreateVehicleInput!) {
+  createVehicle(input: $input) {
+    ...VehicleCore
+  }
+}
+    ${VehicleCoreFragmentDoc}`;
+export type CreateVehicleMutationFn = Apollo.MutationFunction<Types.CreateVehicleMutation, Types.CreateVehicleMutationVariables>;
+
+/**
+ * __useCreateVehicleMutation__
+ *
+ * To run a mutation, you first call `useCreateVehicleMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateVehicleMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createVehicleMutation, { data, loading, error }] = useCreateVehicleMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateVehicleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateVehicleMutation, Types.CreateVehicleMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.CreateVehicleMutation, Types.CreateVehicleMutationVariables>(CreateVehicleDocument, options);
+      }
+export type CreateVehicleMutationHookResult = ReturnType<typeof useCreateVehicleMutation>;
+export type CreateVehicleMutationResult = Apollo.MutationResult<Types.CreateVehicleMutation>;
+export type CreateVehicleMutationOptions = Apollo.BaseMutationOptions<Types.CreateVehicleMutation, Types.CreateVehicleMutationVariables>;
+export const UpdateVehicleDocument = gql`
+    mutation UpdateVehicle($id: ID!, $input: UpdateVehicleInput!) {
+  updateVehicle(id: $id, input: $input) {
+    ...VehicleCore
+  }
+}
+    ${VehicleCoreFragmentDoc}`;
+export type UpdateVehicleMutationFn = Apollo.MutationFunction<Types.UpdateVehicleMutation, Types.UpdateVehicleMutationVariables>;
+
+/**
+ * __useUpdateVehicleMutation__
+ *
+ * To run a mutation, you first call `useUpdateVehicleMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateVehicleMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateVehicleMutation, { data, loading, error }] = useUpdateVehicleMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateVehicleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateVehicleMutation, Types.UpdateVehicleMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateVehicleMutation, Types.UpdateVehicleMutationVariables>(UpdateVehicleDocument, options);
+      }
+export type UpdateVehicleMutationHookResult = ReturnType<typeof useUpdateVehicleMutation>;
+export type UpdateVehicleMutationResult = Apollo.MutationResult<Types.UpdateVehicleMutation>;
+export type UpdateVehicleMutationOptions = Apollo.BaseMutationOptions<Types.UpdateVehicleMutation, Types.UpdateVehicleMutationVariables>;
+export const UpdateVehicleStatusDocument = gql`
+    mutation UpdateVehicleStatus($id: ID!, $status: VehicleStatus!) {
+  updateVehicleStatus(id: $id, status: $status) {
+    ...VehicleCore
+  }
+}
+    ${VehicleCoreFragmentDoc}`;
+export type UpdateVehicleStatusMutationFn = Apollo.MutationFunction<Types.UpdateVehicleStatusMutation, Types.UpdateVehicleStatusMutationVariables>;
+
+/**
+ * __useUpdateVehicleStatusMutation__
+ *
+ * To run a mutation, you first call `useUpdateVehicleStatusMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateVehicleStatusMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateVehicleStatusMutation, { data, loading, error }] = useUpdateVehicleStatusMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      status: // value for 'status'
+ *   },
+ * });
+ */
+export function useUpdateVehicleStatusMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateVehicleStatusMutation, Types.UpdateVehicleStatusMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateVehicleStatusMutation, Types.UpdateVehicleStatusMutationVariables>(UpdateVehicleStatusDocument, options);
+      }
+export type UpdateVehicleStatusMutationHookResult = ReturnType<typeof useUpdateVehicleStatusMutation>;
+export type UpdateVehicleStatusMutationResult = Apollo.MutationResult<Types.UpdateVehicleStatusMutation>;
+export type UpdateVehicleStatusMutationOptions = Apollo.BaseMutationOptions<Types.UpdateVehicleStatusMutation, Types.UpdateVehicleStatusMutationVariables>;
+export const UpdateVehicleLocationDocument = gql`
+    mutation UpdateVehicleLocation($id: ID!, $location: JSON!) {
+  updateVehicleLocation(id: $id, location: $location) {
+    ...VehicleCore
+  }
+}
+    ${VehicleCoreFragmentDoc}`;
+export type UpdateVehicleLocationMutationFn = Apollo.MutationFunction<Types.UpdateVehicleLocationMutation, Types.UpdateVehicleLocationMutationVariables>;
+
+/**
+ * __useUpdateVehicleLocationMutation__
+ *
+ * To run a mutation, you first call `useUpdateVehicleLocationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateVehicleLocationMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateVehicleLocationMutation, { data, loading, error }] = useUpdateVehicleLocationMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      location: // value for 'location'
+ *   },
+ * });
+ */
+export function useUpdateVehicleLocationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateVehicleLocationMutation, Types.UpdateVehicleLocationMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateVehicleLocationMutation, Types.UpdateVehicleLocationMutationVariables>(UpdateVehicleLocationDocument, options);
+      }
+export type UpdateVehicleLocationMutationHookResult = ReturnType<typeof useUpdateVehicleLocationMutation>;
+export type UpdateVehicleLocationMutationResult = Apollo.MutationResult<Types.UpdateVehicleLocationMutation>;
+export type UpdateVehicleLocationMutationOptions = Apollo.BaseMutationOptions<Types.UpdateVehicleLocationMutation, Types.UpdateVehicleLocationMutationVariables>;
+export const DeleteVehicleDocument = gql`
+    mutation DeleteVehicle($id: ID!) {
+  deleteVehicle(id: $id)
+}
+    `;
+export type DeleteVehicleMutationFn = Apollo.MutationFunction<Types.DeleteVehicleMutation, Types.DeleteVehicleMutationVariables>;
+
+/**
+ * __useDeleteVehicleMutation__
+ *
+ * To run a mutation, you first call `useDeleteVehicleMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteVehicleMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteVehicleMutation, { data, loading, error }] = useDeleteVehicleMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteVehicleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteVehicleMutation, Types.DeleteVehicleMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.DeleteVehicleMutation, Types.DeleteVehicleMutationVariables>(DeleteVehicleDocument, options);
+      }
+export type DeleteVehicleMutationHookResult = ReturnType<typeof useDeleteVehicleMutation>;
+export type DeleteVehicleMutationResult = Apollo.MutationResult<Types.DeleteVehicleMutation>;
+export type DeleteVehicleMutationOptions = Apollo.BaseMutationOptions<Types.DeleteVehicleMutation, Types.DeleteVehicleMutationVariables>;
+export const CreateDriverDocument = gql`
+    mutation CreateDriver($input: CreateDriverInput!) {
+  createDriver(input: $input) {
+    ...DriverCore
+  }
+}
+    ${DriverCoreFragmentDoc}`;
+export type CreateDriverMutationFn = Apollo.MutationFunction<Types.CreateDriverMutation, Types.CreateDriverMutationVariables>;
+
+/**
+ * __useCreateDriverMutation__
+ *
+ * To run a mutation, you first call `useCreateDriverMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateDriverMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createDriverMutation, { data, loading, error }] = useCreateDriverMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateDriverMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateDriverMutation, Types.CreateDriverMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.CreateDriverMutation, Types.CreateDriverMutationVariables>(CreateDriverDocument, options);
+      }
+export type CreateDriverMutationHookResult = ReturnType<typeof useCreateDriverMutation>;
+export type CreateDriverMutationResult = Apollo.MutationResult<Types.CreateDriverMutation>;
+export type CreateDriverMutationOptions = Apollo.BaseMutationOptions<Types.CreateDriverMutation, Types.CreateDriverMutationVariables>;
+export const UpdateDriverDocument = gql`
+    mutation UpdateDriver($id: ID!, $input: UpdateDriverInput!) {
+  updateDriver(id: $id, input: $input) {
+    ...DriverCore
+  }
+}
+    ${DriverCoreFragmentDoc}`;
+export type UpdateDriverMutationFn = Apollo.MutationFunction<Types.UpdateDriverMutation, Types.UpdateDriverMutationVariables>;
+
+/**
+ * __useUpdateDriverMutation__
+ *
+ * To run a mutation, you first call `useUpdateDriverMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateDriverMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateDriverMutation, { data, loading, error }] = useUpdateDriverMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateDriverMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateDriverMutation, Types.UpdateDriverMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateDriverMutation, Types.UpdateDriverMutationVariables>(UpdateDriverDocument, options);
+      }
+export type UpdateDriverMutationHookResult = ReturnType<typeof useUpdateDriverMutation>;
+export type UpdateDriverMutationResult = Apollo.MutationResult<Types.UpdateDriverMutation>;
+export type UpdateDriverMutationOptions = Apollo.BaseMutationOptions<Types.UpdateDriverMutation, Types.UpdateDriverMutationVariables>;
+export const UpdateDriverStatusDocument = gql`
+    mutation UpdateDriverStatus($id: ID!, $status: DriverStatus!) {
+  updateDriverStatus(id: $id, status: $status) {
+    ...DriverCore
+  }
+}
+    ${DriverCoreFragmentDoc}`;
+export type UpdateDriverStatusMutationFn = Apollo.MutationFunction<Types.UpdateDriverStatusMutation, Types.UpdateDriverStatusMutationVariables>;
+
+/**
+ * __useUpdateDriverStatusMutation__
+ *
+ * To run a mutation, you first call `useUpdateDriverStatusMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateDriverStatusMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateDriverStatusMutation, { data, loading, error }] = useUpdateDriverStatusMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      status: // value for 'status'
+ *   },
+ * });
+ */
+export function useUpdateDriverStatusMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateDriverStatusMutation, Types.UpdateDriverStatusMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateDriverStatusMutation, Types.UpdateDriverStatusMutationVariables>(UpdateDriverStatusDocument, options);
+      }
+export type UpdateDriverStatusMutationHookResult = ReturnType<typeof useUpdateDriverStatusMutation>;
+export type UpdateDriverStatusMutationResult = Apollo.MutationResult<Types.UpdateDriverStatusMutation>;
+export type UpdateDriverStatusMutationOptions = Apollo.BaseMutationOptions<Types.UpdateDriverStatusMutation, Types.UpdateDriverStatusMutationVariables>;
+export const AssignDriverVehicleDocument = gql`
+    mutation AssignDriverVehicle($id: ID!, $vehicleId: ID) {
+  assignDriverVehicle(id: $id, vehicleId: $vehicleId) {
+    ...DriverCore
+  }
+}
+    ${DriverCoreFragmentDoc}`;
+export type AssignDriverVehicleMutationFn = Apollo.MutationFunction<Types.AssignDriverVehicleMutation, Types.AssignDriverVehicleMutationVariables>;
+
+/**
+ * __useAssignDriverVehicleMutation__
+ *
+ * To run a mutation, you first call `useAssignDriverVehicleMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAssignDriverVehicleMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [assignDriverVehicleMutation, { data, loading, error }] = useAssignDriverVehicleMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      vehicleId: // value for 'vehicleId'
+ *   },
+ * });
+ */
+export function useAssignDriverVehicleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AssignDriverVehicleMutation, Types.AssignDriverVehicleMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.AssignDriverVehicleMutation, Types.AssignDriverVehicleMutationVariables>(AssignDriverVehicleDocument, options);
+      }
+export type AssignDriverVehicleMutationHookResult = ReturnType<typeof useAssignDriverVehicleMutation>;
+export type AssignDriverVehicleMutationResult = Apollo.MutationResult<Types.AssignDriverVehicleMutation>;
+export type AssignDriverVehicleMutationOptions = Apollo.BaseMutationOptions<Types.AssignDriverVehicleMutation, Types.AssignDriverVehicleMutationVariables>;
+export const DeleteDriverDocument = gql`
+    mutation DeleteDriver($id: ID!) {
+  deleteDriver(id: $id)
+}
+    `;
+export type DeleteDriverMutationFn = Apollo.MutationFunction<Types.DeleteDriverMutation, Types.DeleteDriverMutationVariables>;
+
+/**
+ * __useDeleteDriverMutation__
+ *
+ * To run a mutation, you first call `useDeleteDriverMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteDriverMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteDriverMutation, { data, loading, error }] = useDeleteDriverMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteDriverMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteDriverMutation, Types.DeleteDriverMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.DeleteDriverMutation, Types.DeleteDriverMutationVariables>(DeleteDriverDocument, options);
+      }
+export type DeleteDriverMutationHookResult = ReturnType<typeof useDeleteDriverMutation>;
+export type DeleteDriverMutationResult = Apollo.MutationResult<Types.DeleteDriverMutation>;
+export type DeleteDriverMutationOptions = Apollo.BaseMutationOptions<Types.DeleteDriverMutation, Types.DeleteDriverMutationVariables>;
+export const CreateWarehouseDocument = gql`
+    mutation CreateWarehouse($input: CreateWarehouseInput!) {
+  createWarehouse(input: $input) {
+    ...WarehouseCore
+  }
+}
+    ${WarehouseCoreFragmentDoc}`;
+export type CreateWarehouseMutationFn = Apollo.MutationFunction<Types.CreateWarehouseMutation, Types.CreateWarehouseMutationVariables>;
+
+/**
+ * __useCreateWarehouseMutation__
+ *
+ * To run a mutation, you first call `useCreateWarehouseMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateWarehouseMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createWarehouseMutation, { data, loading, error }] = useCreateWarehouseMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateWarehouseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateWarehouseMutation, Types.CreateWarehouseMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.CreateWarehouseMutation, Types.CreateWarehouseMutationVariables>(CreateWarehouseDocument, options);
+      }
+export type CreateWarehouseMutationHookResult = ReturnType<typeof useCreateWarehouseMutation>;
+export type CreateWarehouseMutationResult = Apollo.MutationResult<Types.CreateWarehouseMutation>;
+export type CreateWarehouseMutationOptions = Apollo.BaseMutationOptions<Types.CreateWarehouseMutation, Types.CreateWarehouseMutationVariables>;
+export const UpdateWarehouseDocument = gql`
+    mutation UpdateWarehouse($id: ID!, $input: UpdateWarehouseInput!) {
+  updateWarehouse(id: $id, input: $input) {
+    ...WarehouseCore
+  }
+}
+    ${WarehouseCoreFragmentDoc}`;
+export type UpdateWarehouseMutationFn = Apollo.MutationFunction<Types.UpdateWarehouseMutation, Types.UpdateWarehouseMutationVariables>;
+
+/**
+ * __useUpdateWarehouseMutation__
+ *
+ * To run a mutation, you first call `useUpdateWarehouseMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateWarehouseMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateWarehouseMutation, { data, loading, error }] = useUpdateWarehouseMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateWarehouseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateWarehouseMutation, Types.UpdateWarehouseMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateWarehouseMutation, Types.UpdateWarehouseMutationVariables>(UpdateWarehouseDocument, options);
+      }
+export type UpdateWarehouseMutationHookResult = ReturnType<typeof useUpdateWarehouseMutation>;
+export type UpdateWarehouseMutationResult = Apollo.MutationResult<Types.UpdateWarehouseMutation>;
+export type UpdateWarehouseMutationOptions = Apollo.BaseMutationOptions<Types.UpdateWarehouseMutation, Types.UpdateWarehouseMutationVariables>;
+export const DeleteWarehouseDocument = gql`
+    mutation DeleteWarehouse($id: ID!) {
+  deleteWarehouse(id: $id)
+}
+    `;
+export type DeleteWarehouseMutationFn = Apollo.MutationFunction<Types.DeleteWarehouseMutation, Types.DeleteWarehouseMutationVariables>;
+
+/**
+ * __useDeleteWarehouseMutation__
+ *
+ * To run a mutation, you first call `useDeleteWarehouseMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteWarehouseMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteWarehouseMutation, { data, loading, error }] = useDeleteWarehouseMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteWarehouseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteWarehouseMutation, Types.DeleteWarehouseMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.DeleteWarehouseMutation, Types.DeleteWarehouseMutationVariables>(DeleteWarehouseDocument, options);
+      }
+export type DeleteWarehouseMutationHookResult = ReturnType<typeof useDeleteWarehouseMutation>;
+export type DeleteWarehouseMutationResult = Apollo.MutationResult<Types.DeleteWarehouseMutation>;
+export type DeleteWarehouseMutationOptions = Apollo.BaseMutationOptions<Types.DeleteWarehouseMutation, Types.DeleteWarehouseMutationVariables>;
+export const CreateInventoryItemDocument = gql`
+    mutation CreateInventoryItem($input: CreateInventoryItemInput!) {
+  createInventoryItem(input: $input) {
+    ...InventoryItemCore
+  }
+}
+    ${InventoryItemCoreFragmentDoc}`;
+export type CreateInventoryItemMutationFn = Apollo.MutationFunction<Types.CreateInventoryItemMutation, Types.CreateInventoryItemMutationVariables>;
+
+/**
+ * __useCreateInventoryItemMutation__
+ *
+ * To run a mutation, you first call `useCreateInventoryItemMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateInventoryItemMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createInventoryItemMutation, { data, loading, error }] = useCreateInventoryItemMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateInventoryItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateInventoryItemMutation, Types.CreateInventoryItemMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.CreateInventoryItemMutation, Types.CreateInventoryItemMutationVariables>(CreateInventoryItemDocument, options);
+      }
+export type CreateInventoryItemMutationHookResult = ReturnType<typeof useCreateInventoryItemMutation>;
+export type CreateInventoryItemMutationResult = Apollo.MutationResult<Types.CreateInventoryItemMutation>;
+export type CreateInventoryItemMutationOptions = Apollo.BaseMutationOptions<Types.CreateInventoryItemMutation, Types.CreateInventoryItemMutationVariables>;
+export const UpdateInventoryItemDocument = gql`
+    mutation UpdateInventoryItem($id: ID!, $input: UpdateInventoryItemInput!) {
+  updateInventoryItem(id: $id, input: $input) {
+    ...InventoryItemCore
+  }
+}
+    ${InventoryItemCoreFragmentDoc}`;
+export type UpdateInventoryItemMutationFn = Apollo.MutationFunction<Types.UpdateInventoryItemMutation, Types.UpdateInventoryItemMutationVariables>;
+
+/**
+ * __useUpdateInventoryItemMutation__
+ *
+ * To run a mutation, you first call `useUpdateInventoryItemMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateInventoryItemMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateInventoryItemMutation, { data, loading, error }] = useUpdateInventoryItemMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateInventoryItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateInventoryItemMutation, Types.UpdateInventoryItemMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateInventoryItemMutation, Types.UpdateInventoryItemMutationVariables>(UpdateInventoryItemDocument, options);
+      }
+export type UpdateInventoryItemMutationHookResult = ReturnType<typeof useUpdateInventoryItemMutation>;
+export type UpdateInventoryItemMutationResult = Apollo.MutationResult<Types.UpdateInventoryItemMutation>;
+export type UpdateInventoryItemMutationOptions = Apollo.BaseMutationOptions<Types.UpdateInventoryItemMutation, Types.UpdateInventoryItemMutationVariables>;
+export const AdjustInventoryStockDocument = gql`
+    mutation AdjustInventoryStock($input: AdjustInventoryStockInput!) {
+  adjustInventoryStock(input: $input) {
+    ...InventoryItemCore
+  }
+}
+    ${InventoryItemCoreFragmentDoc}`;
+export type AdjustInventoryStockMutationFn = Apollo.MutationFunction<Types.AdjustInventoryStockMutation, Types.AdjustInventoryStockMutationVariables>;
+
+/**
+ * __useAdjustInventoryStockMutation__
+ *
+ * To run a mutation, you first call `useAdjustInventoryStockMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAdjustInventoryStockMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [adjustInventoryStockMutation, { data, loading, error }] = useAdjustInventoryStockMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useAdjustInventoryStockMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AdjustInventoryStockMutation, Types.AdjustInventoryStockMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.AdjustInventoryStockMutation, Types.AdjustInventoryStockMutationVariables>(AdjustInventoryStockDocument, options);
+      }
+export type AdjustInventoryStockMutationHookResult = ReturnType<typeof useAdjustInventoryStockMutation>;
+export type AdjustInventoryStockMutationResult = Apollo.MutationResult<Types.AdjustInventoryStockMutation>;
+export type AdjustInventoryStockMutationOptions = Apollo.BaseMutationOptions<Types.AdjustInventoryStockMutation, Types.AdjustInventoryStockMutationVariables>;
+export const DeleteInventoryItemDocument = gql`
+    mutation DeleteInventoryItem($id: ID!) {
+  deleteInventoryItem(id: $id)
+}
+    `;
+export type DeleteInventoryItemMutationFn = Apollo.MutationFunction<Types.DeleteInventoryItemMutation, Types.DeleteInventoryItemMutationVariables>;
+
+/**
+ * __useDeleteInventoryItemMutation__
+ *
+ * To run a mutation, you first call `useDeleteInventoryItemMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteInventoryItemMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteInventoryItemMutation, { data, loading, error }] = useDeleteInventoryItemMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteInventoryItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteInventoryItemMutation, Types.DeleteInventoryItemMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.DeleteInventoryItemMutation, Types.DeleteInventoryItemMutationVariables>(DeleteInventoryItemDocument, options);
+      }
+export type DeleteInventoryItemMutationHookResult = ReturnType<typeof useDeleteInventoryItemMutation>;
+export type DeleteInventoryItemMutationResult = Apollo.MutationResult<Types.DeleteInventoryItemMutation>;
+export type DeleteInventoryItemMutationOptions = Apollo.BaseMutationOptions<Types.DeleteInventoryItemMutation, Types.DeleteInventoryItemMutationVariables>;
+export const CreateRouteDocument = gql`
+    mutation CreateRoute($input: CreateRouteInput!) {
+  createRoute(input: $input) {
+    ...RouteCore
+  }
+}
+    ${RouteCoreFragmentDoc}`;
+export type CreateRouteMutationFn = Apollo.MutationFunction<Types.CreateRouteMutation, Types.CreateRouteMutationVariables>;
+
+/**
+ * __useCreateRouteMutation__
+ *
+ * To run a mutation, you first call `useCreateRouteMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateRouteMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createRouteMutation, { data, loading, error }] = useCreateRouteMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateRouteMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateRouteMutation, Types.CreateRouteMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.CreateRouteMutation, Types.CreateRouteMutationVariables>(CreateRouteDocument, options);
+      }
+export type CreateRouteMutationHookResult = ReturnType<typeof useCreateRouteMutation>;
+export type CreateRouteMutationResult = Apollo.MutationResult<Types.CreateRouteMutation>;
+export type CreateRouteMutationOptions = Apollo.BaseMutationOptions<Types.CreateRouteMutation, Types.CreateRouteMutationVariables>;
+export const UpdateRouteDocument = gql`
+    mutation UpdateRoute($id: ID!, $input: UpdateRouteInput!) {
+  updateRoute(id: $id, input: $input) {
+    ...RouteCore
+  }
+}
+    ${RouteCoreFragmentDoc}`;
+export type UpdateRouteMutationFn = Apollo.MutationFunction<Types.UpdateRouteMutation, Types.UpdateRouteMutationVariables>;
+
+/**
+ * __useUpdateRouteMutation__
+ *
+ * To run a mutation, you first call `useUpdateRouteMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateRouteMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateRouteMutation, { data, loading, error }] = useUpdateRouteMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateRouteMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateRouteMutation, Types.UpdateRouteMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateRouteMutation, Types.UpdateRouteMutationVariables>(UpdateRouteDocument, options);
+      }
+export type UpdateRouteMutationHookResult = ReturnType<typeof useUpdateRouteMutation>;
+export type UpdateRouteMutationResult = Apollo.MutationResult<Types.UpdateRouteMutation>;
+export type UpdateRouteMutationOptions = Apollo.BaseMutationOptions<Types.UpdateRouteMutation, Types.UpdateRouteMutationVariables>;
+export const OptimizeRouteDocument = gql`
+    mutation OptimizeRoute($id: ID!) {
+  optimizeRoute(id: $id) {
+    ...RouteCore
+  }
+}
+    ${RouteCoreFragmentDoc}`;
+export type OptimizeRouteMutationFn = Apollo.MutationFunction<Types.OptimizeRouteMutation, Types.OptimizeRouteMutationVariables>;
+
+/**
+ * __useOptimizeRouteMutation__
+ *
+ * To run a mutation, you first call `useOptimizeRouteMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useOptimizeRouteMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [optimizeRouteMutation, { data, loading, error }] = useOptimizeRouteMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useOptimizeRouteMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.OptimizeRouteMutation, Types.OptimizeRouteMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.OptimizeRouteMutation, Types.OptimizeRouteMutationVariables>(OptimizeRouteDocument, options);
+      }
+export type OptimizeRouteMutationHookResult = ReturnType<typeof useOptimizeRouteMutation>;
+export type OptimizeRouteMutationResult = Apollo.MutationResult<Types.OptimizeRouteMutation>;
+export type OptimizeRouteMutationOptions = Apollo.BaseMutationOptions<Types.OptimizeRouteMutation, Types.OptimizeRouteMutationVariables>;
+export const DeleteRouteDocument = gql`
+    mutation DeleteRoute($id: ID!) {
+  deleteRoute(id: $id)
+}
+    `;
+export type DeleteRouteMutationFn = Apollo.MutationFunction<Types.DeleteRouteMutation, Types.DeleteRouteMutationVariables>;
+
+/**
+ * __useDeleteRouteMutation__
+ *
+ * To run a mutation, you first call `useDeleteRouteMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteRouteMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteRouteMutation, { data, loading, error }] = useDeleteRouteMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteRouteMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteRouteMutation, Types.DeleteRouteMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.DeleteRouteMutation, Types.DeleteRouteMutationVariables>(DeleteRouteDocument, options);
+      }
+export type DeleteRouteMutationHookResult = ReturnType<typeof useDeleteRouteMutation>;
+export type DeleteRouteMutationResult = Apollo.MutationResult<Types.DeleteRouteMutation>;
+export type DeleteRouteMutationOptions = Apollo.BaseMutationOptions<Types.DeleteRouteMutation, Types.DeleteRouteMutationVariables>;
+export const CreateShipmentDocument = gql`
+    mutation CreateShipment($input: CreateShipmentInput!) {
+  createShipment(input: $input) {
+    ...ShipmentCore
+  }
+}
+    ${ShipmentCoreFragmentDoc}`;
+export type CreateShipmentMutationFn = Apollo.MutationFunction<Types.CreateShipmentMutation, Types.CreateShipmentMutationVariables>;
+
+/**
+ * __useCreateShipmentMutation__
+ *
+ * To run a mutation, you first call `useCreateShipmentMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateShipmentMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createShipmentMutation, { data, loading, error }] = useCreateShipmentMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateShipmentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateShipmentMutation, Types.CreateShipmentMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.CreateShipmentMutation, Types.CreateShipmentMutationVariables>(CreateShipmentDocument, options);
+      }
+export type CreateShipmentMutationHookResult = ReturnType<typeof useCreateShipmentMutation>;
+export type CreateShipmentMutationResult = Apollo.MutationResult<Types.CreateShipmentMutation>;
+export type CreateShipmentMutationOptions = Apollo.BaseMutationOptions<Types.CreateShipmentMutation, Types.CreateShipmentMutationVariables>;
+export const UpdateShipmentDocument = gql`
+    mutation UpdateShipment($id: ID!, $input: UpdateShipmentInput!) {
+  updateShipment(id: $id, input: $input) {
+    ...ShipmentCore
+  }
+}
+    ${ShipmentCoreFragmentDoc}`;
+export type UpdateShipmentMutationFn = Apollo.MutationFunction<Types.UpdateShipmentMutation, Types.UpdateShipmentMutationVariables>;
+
+/**
+ * __useUpdateShipmentMutation__
+ *
+ * To run a mutation, you first call `useUpdateShipmentMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateShipmentMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateShipmentMutation, { data, loading, error }] = useUpdateShipmentMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateShipmentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateShipmentMutation, Types.UpdateShipmentMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateShipmentMutation, Types.UpdateShipmentMutationVariables>(UpdateShipmentDocument, options);
+      }
+export type UpdateShipmentMutationHookResult = ReturnType<typeof useUpdateShipmentMutation>;
+export type UpdateShipmentMutationResult = Apollo.MutationResult<Types.UpdateShipmentMutation>;
+export type UpdateShipmentMutationOptions = Apollo.BaseMutationOptions<Types.UpdateShipmentMutation, Types.UpdateShipmentMutationVariables>;
+export const DeleteShipmentDocument = gql`
+    mutation DeleteShipment($id: ID!) {
+  deleteShipment(id: $id)
+}
+    `;
+export type DeleteShipmentMutationFn = Apollo.MutationFunction<Types.DeleteShipmentMutation, Types.DeleteShipmentMutationVariables>;
+
+/**
+ * __useDeleteShipmentMutation__
+ *
+ * To run a mutation, you first call `useDeleteShipmentMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteShipmentMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteShipmentMutation, { data, loading, error }] = useDeleteShipmentMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteShipmentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteShipmentMutation, Types.DeleteShipmentMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.DeleteShipmentMutation, Types.DeleteShipmentMutationVariables>(DeleteShipmentDocument, options);
+      }
+export type DeleteShipmentMutationHookResult = ReturnType<typeof useDeleteShipmentMutation>;
+export type DeleteShipmentMutationResult = Apollo.MutationResult<Types.DeleteShipmentMutation>;
+export type DeleteShipmentMutationOptions = Apollo.BaseMutationOptions<Types.DeleteShipmentMutation, Types.DeleteShipmentMutationVariables>;
+export const AddTrackingEventDocument = gql`
+    mutation AddTrackingEvent($input: AddTrackingEventInput!) {
+  addTrackingEvent(input: $input) {
+    id
+    shipmentId
+    eventType
+    location
+    details
+    timestamp
+  }
+}
+    `;
+export type AddTrackingEventMutationFn = Apollo.MutationFunction<Types.AddTrackingEventMutation, Types.AddTrackingEventMutationVariables>;
+
+/**
+ * __useAddTrackingEventMutation__
+ *
+ * To run a mutation, you first call `useAddTrackingEventMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddTrackingEventMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addTrackingEventMutation, { data, loading, error }] = useAddTrackingEventMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useAddTrackingEventMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AddTrackingEventMutation, Types.AddTrackingEventMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.AddTrackingEventMutation, Types.AddTrackingEventMutationVariables>(AddTrackingEventDocument, options);
+      }
+export type AddTrackingEventMutationHookResult = ReturnType<typeof useAddTrackingEventMutation>;
+export type AddTrackingEventMutationResult = Apollo.MutationResult<Types.AddTrackingEventMutation>;
+export type AddTrackingEventMutationOptions = Apollo.BaseMutationOptions<Types.AddTrackingEventMutation, Types.AddTrackingEventMutationVariables>;
+export const CreateServiceProviderDocument = gql`
+    mutation CreateServiceProvider($input: CreateServiceProviderInput!) {
+  createServiceProvider(input: $input) {
+    ...ServiceProviderCore
+  }
+}
+    ${ServiceProviderCoreFragmentDoc}`;
+export type CreateServiceProviderMutationFn = Apollo.MutationFunction<Types.CreateServiceProviderMutation, Types.CreateServiceProviderMutationVariables>;
+
+/**
+ * __useCreateServiceProviderMutation__
+ *
+ * To run a mutation, you first call `useCreateServiceProviderMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateServiceProviderMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createServiceProviderMutation, { data, loading, error }] = useCreateServiceProviderMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateServiceProviderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateServiceProviderMutation, Types.CreateServiceProviderMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.CreateServiceProviderMutation, Types.CreateServiceProviderMutationVariables>(CreateServiceProviderDocument, options);
+      }
+export type CreateServiceProviderMutationHookResult = ReturnType<typeof useCreateServiceProviderMutation>;
+export type CreateServiceProviderMutationResult = Apollo.MutationResult<Types.CreateServiceProviderMutation>;
+export type CreateServiceProviderMutationOptions = Apollo.BaseMutationOptions<Types.CreateServiceProviderMutation, Types.CreateServiceProviderMutationVariables>;
+export const UpdateServiceProviderDocument = gql`
+    mutation UpdateServiceProvider($id: ID!, $input: UpdateServiceProviderInput!) {
+  updateServiceProvider(id: $id, input: $input) {
+    ...ServiceProviderCore
+  }
+}
+    ${ServiceProviderCoreFragmentDoc}`;
+export type UpdateServiceProviderMutationFn = Apollo.MutationFunction<Types.UpdateServiceProviderMutation, Types.UpdateServiceProviderMutationVariables>;
+
+/**
+ * __useUpdateServiceProviderMutation__
+ *
+ * To run a mutation, you first call `useUpdateServiceProviderMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateServiceProviderMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateServiceProviderMutation, { data, loading, error }] = useUpdateServiceProviderMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateServiceProviderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateServiceProviderMutation, Types.UpdateServiceProviderMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateServiceProviderMutation, Types.UpdateServiceProviderMutationVariables>(UpdateServiceProviderDocument, options);
+      }
+export type UpdateServiceProviderMutationHookResult = ReturnType<typeof useUpdateServiceProviderMutation>;
+export type UpdateServiceProviderMutationResult = Apollo.MutationResult<Types.UpdateServiceProviderMutation>;
+export type UpdateServiceProviderMutationOptions = Apollo.BaseMutationOptions<Types.UpdateServiceProviderMutation, Types.UpdateServiceProviderMutationVariables>;
+export const DeleteServiceProviderDocument = gql`
+    mutation DeleteServiceProvider($id: ID!) {
+  deleteServiceProvider(id: $id)
+}
+    `;
+export type DeleteServiceProviderMutationFn = Apollo.MutationFunction<Types.DeleteServiceProviderMutation, Types.DeleteServiceProviderMutationVariables>;
+
+/**
+ * __useDeleteServiceProviderMutation__
+ *
+ * To run a mutation, you first call `useDeleteServiceProviderMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteServiceProviderMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteServiceProviderMutation, { data, loading, error }] = useDeleteServiceProviderMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteServiceProviderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteServiceProviderMutation, Types.DeleteServiceProviderMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.DeleteServiceProviderMutation, Types.DeleteServiceProviderMutationVariables>(DeleteServiceProviderDocument, options);
+      }
+export type DeleteServiceProviderMutationHookResult = ReturnType<typeof useDeleteServiceProviderMutation>;
+export type DeleteServiceProviderMutationResult = Apollo.MutationResult<Types.DeleteServiceProviderMutation>;
+export type DeleteServiceProviderMutationOptions = Apollo.BaseMutationOptions<Types.DeleteServiceProviderMutation, Types.DeleteServiceProviderMutationVariables>;
+export const CreateServiceOfferingDocument = gql`
+    mutation CreateServiceOffering($input: CreateServiceOfferingInput!) {
+  createServiceOffering(input: $input) {
+    ...ServiceOfferingCore
+  }
+}
+    ${ServiceOfferingCoreFragmentDoc}`;
+export type CreateServiceOfferingMutationFn = Apollo.MutationFunction<Types.CreateServiceOfferingMutation, Types.CreateServiceOfferingMutationVariables>;
+
+/**
+ * __useCreateServiceOfferingMutation__
+ *
+ * To run a mutation, you first call `useCreateServiceOfferingMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateServiceOfferingMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createServiceOfferingMutation, { data, loading, error }] = useCreateServiceOfferingMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateServiceOfferingMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateServiceOfferingMutation, Types.CreateServiceOfferingMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.CreateServiceOfferingMutation, Types.CreateServiceOfferingMutationVariables>(CreateServiceOfferingDocument, options);
+      }
+export type CreateServiceOfferingMutationHookResult = ReturnType<typeof useCreateServiceOfferingMutation>;
+export type CreateServiceOfferingMutationResult = Apollo.MutationResult<Types.CreateServiceOfferingMutation>;
+export type CreateServiceOfferingMutationOptions = Apollo.BaseMutationOptions<Types.CreateServiceOfferingMutation, Types.CreateServiceOfferingMutationVariables>;
+export const UpdateServiceOfferingDocument = gql`
+    mutation UpdateServiceOffering($id: ID!, $input: UpdateServiceOfferingInput!) {
+  updateServiceOffering(id: $id, input: $input) {
+    ...ServiceOfferingCore
+  }
+}
+    ${ServiceOfferingCoreFragmentDoc}`;
+export type UpdateServiceOfferingMutationFn = Apollo.MutationFunction<Types.UpdateServiceOfferingMutation, Types.UpdateServiceOfferingMutationVariables>;
+
+/**
+ * __useUpdateServiceOfferingMutation__
+ *
+ * To run a mutation, you first call `useUpdateServiceOfferingMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateServiceOfferingMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateServiceOfferingMutation, { data, loading, error }] = useUpdateServiceOfferingMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateServiceOfferingMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateServiceOfferingMutation, Types.UpdateServiceOfferingMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateServiceOfferingMutation, Types.UpdateServiceOfferingMutationVariables>(UpdateServiceOfferingDocument, options);
+      }
+export type UpdateServiceOfferingMutationHookResult = ReturnType<typeof useUpdateServiceOfferingMutation>;
+export type UpdateServiceOfferingMutationResult = Apollo.MutationResult<Types.UpdateServiceOfferingMutation>;
+export type UpdateServiceOfferingMutationOptions = Apollo.BaseMutationOptions<Types.UpdateServiceOfferingMutation, Types.UpdateServiceOfferingMutationVariables>;
+export const DeleteServiceOfferingDocument = gql`
+    mutation DeleteServiceOffering($id: ID!) {
+  deleteServiceOffering(id: $id)
+}
+    `;
+export type DeleteServiceOfferingMutationFn = Apollo.MutationFunction<Types.DeleteServiceOfferingMutation, Types.DeleteServiceOfferingMutationVariables>;
+
+/**
+ * __useDeleteServiceOfferingMutation__
+ *
+ * To run a mutation, you first call `useDeleteServiceOfferingMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteServiceOfferingMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteServiceOfferingMutation, { data, loading, error }] = useDeleteServiceOfferingMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteServiceOfferingMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteServiceOfferingMutation, Types.DeleteServiceOfferingMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.DeleteServiceOfferingMutation, Types.DeleteServiceOfferingMutationVariables>(DeleteServiceOfferingDocument, options);
+      }
+export type DeleteServiceOfferingMutationHookResult = ReturnType<typeof useDeleteServiceOfferingMutation>;
+export type DeleteServiceOfferingMutationResult = Apollo.MutationResult<Types.DeleteServiceOfferingMutation>;
+export type DeleteServiceOfferingMutationOptions = Apollo.BaseMutationOptions<Types.DeleteServiceOfferingMutation, Types.DeleteServiceOfferingMutationVariables>;
+export const CreateMovethewheelsReportDocument = gql`
+    mutation CreateMovethewheelsReport($input: CreateMovethewheelsReportInput!) {
+  createMovethewheelsReport(input: $input) {
+    ...MovethewheelsReportCore
+  }
+}
+    ${MovethewheelsReportCoreFragmentDoc}`;
+export type CreateMovethewheelsReportMutationFn = Apollo.MutationFunction<Types.CreateMovethewheelsReportMutation, Types.CreateMovethewheelsReportMutationVariables>;
+
+/**
+ * __useCreateMovethewheelsReportMutation__
+ *
+ * To run a mutation, you first call `useCreateMovethewheelsReportMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateMovethewheelsReportMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createMovethewheelsReportMutation, { data, loading, error }] = useCreateMovethewheelsReportMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateMovethewheelsReportMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateMovethewheelsReportMutation, Types.CreateMovethewheelsReportMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.CreateMovethewheelsReportMutation, Types.CreateMovethewheelsReportMutationVariables>(CreateMovethewheelsReportDocument, options);
+      }
+export type CreateMovethewheelsReportMutationHookResult = ReturnType<typeof useCreateMovethewheelsReportMutation>;
+export type CreateMovethewheelsReportMutationResult = Apollo.MutationResult<Types.CreateMovethewheelsReportMutation>;
+export type CreateMovethewheelsReportMutationOptions = Apollo.BaseMutationOptions<Types.CreateMovethewheelsReportMutation, Types.CreateMovethewheelsReportMutationVariables>;
+export const UpdateMovethewheelsReportDocument = gql`
+    mutation UpdateMovethewheelsReport($id: ID!, $input: UpdateMovethewheelsReportInput!) {
+  updateMovethewheelsReport(id: $id, input: $input) {
+    ...MovethewheelsReportCore
+  }
+}
+    ${MovethewheelsReportCoreFragmentDoc}`;
+export type UpdateMovethewheelsReportMutationFn = Apollo.MutationFunction<Types.UpdateMovethewheelsReportMutation, Types.UpdateMovethewheelsReportMutationVariables>;
+
+/**
+ * __useUpdateMovethewheelsReportMutation__
+ *
+ * To run a mutation, you first call `useUpdateMovethewheelsReportMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateMovethewheelsReportMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateMovethewheelsReportMutation, { data, loading, error }] = useUpdateMovethewheelsReportMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateMovethewheelsReportMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateMovethewheelsReportMutation, Types.UpdateMovethewheelsReportMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateMovethewheelsReportMutation, Types.UpdateMovethewheelsReportMutationVariables>(UpdateMovethewheelsReportDocument, options);
+      }
+export type UpdateMovethewheelsReportMutationHookResult = ReturnType<typeof useUpdateMovethewheelsReportMutation>;
+export type UpdateMovethewheelsReportMutationResult = Apollo.MutationResult<Types.UpdateMovethewheelsReportMutation>;
+export type UpdateMovethewheelsReportMutationOptions = Apollo.BaseMutationOptions<Types.UpdateMovethewheelsReportMutation, Types.UpdateMovethewheelsReportMutationVariables>;
+export const DeleteMovethewheelsReportDocument = gql`
+    mutation DeleteMovethewheelsReport($id: ID!) {
+  deleteMovethewheelsReport(id: $id)
+}
+    `;
+export type DeleteMovethewheelsReportMutationFn = Apollo.MutationFunction<Types.DeleteMovethewheelsReportMutation, Types.DeleteMovethewheelsReportMutationVariables>;
+
+/**
+ * __useDeleteMovethewheelsReportMutation__
+ *
+ * To run a mutation, you first call `useDeleteMovethewheelsReportMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteMovethewheelsReportMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteMovethewheelsReportMutation, { data, loading, error }] = useDeleteMovethewheelsReportMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteMovethewheelsReportMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteMovethewheelsReportMutation, Types.DeleteMovethewheelsReportMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.DeleteMovethewheelsReportMutation, Types.DeleteMovethewheelsReportMutationVariables>(DeleteMovethewheelsReportDocument, options);
+      }
+export type DeleteMovethewheelsReportMutationHookResult = ReturnType<typeof useDeleteMovethewheelsReportMutation>;
+export type DeleteMovethewheelsReportMutationResult = Apollo.MutationResult<Types.DeleteMovethewheelsReportMutation>;
+export type DeleteMovethewheelsReportMutationOptions = Apollo.BaseMutationOptions<Types.DeleteMovethewheelsReportMutation, Types.DeleteMovethewheelsReportMutationVariables>;
+export const GenerateMovethewheelsReportDocument = gql`
+    mutation GenerateMovethewheelsReport($input: GenerateMovethewheelsReportInput!) {
+  generateMovethewheelsReport(input: $input) {
+    generatedAt
+    result
+    report {
+      ...MovethewheelsReportCore
+    }
+  }
+}
+    ${MovethewheelsReportCoreFragmentDoc}`;
+export type GenerateMovethewheelsReportMutationFn = Apollo.MutationFunction<Types.GenerateMovethewheelsReportMutation, Types.GenerateMovethewheelsReportMutationVariables>;
+
+/**
+ * __useGenerateMovethewheelsReportMutation__
+ *
+ * To run a mutation, you first call `useGenerateMovethewheelsReportMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useGenerateMovethewheelsReportMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [generateMovethewheelsReportMutation, { data, loading, error }] = useGenerateMovethewheelsReportMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useGenerateMovethewheelsReportMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.GenerateMovethewheelsReportMutation, Types.GenerateMovethewheelsReportMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.GenerateMovethewheelsReportMutation, Types.GenerateMovethewheelsReportMutationVariables>(GenerateMovethewheelsReportDocument, options);
+      }
+export type GenerateMovethewheelsReportMutationHookResult = ReturnType<typeof useGenerateMovethewheelsReportMutation>;
+export type GenerateMovethewheelsReportMutationResult = Apollo.MutationResult<Types.GenerateMovethewheelsReportMutation>;
+export type GenerateMovethewheelsReportMutationOptions = Apollo.BaseMutationOptions<Types.GenerateMovethewheelsReportMutation, Types.GenerateMovethewheelsReportMutationVariables>;
+export const ImportMovethewheelsDataDocument = gql`
+    mutation ImportMovethewheelsData($input: MovethewheelsImportDataInput!) {
+  importData(input: $input) {
+    success
+    message
+    payload
+  }
+}
+    `;
+export type ImportMovethewheelsDataMutationFn = Apollo.MutationFunction<Types.ImportMovethewheelsDataMutation, Types.ImportMovethewheelsDataMutationVariables>;
+
+/**
+ * __useImportMovethewheelsDataMutation__
+ *
+ * To run a mutation, you first call `useImportMovethewheelsDataMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useImportMovethewheelsDataMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [importMovethewheelsDataMutation, { data, loading, error }] = useImportMovethewheelsDataMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useImportMovethewheelsDataMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ImportMovethewheelsDataMutation, Types.ImportMovethewheelsDataMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.ImportMovethewheelsDataMutation, Types.ImportMovethewheelsDataMutationVariables>(ImportMovethewheelsDataDocument, options);
+      }
+export type ImportMovethewheelsDataMutationHookResult = ReturnType<typeof useImportMovethewheelsDataMutation>;
+export type ImportMovethewheelsDataMutationResult = Apollo.MutationResult<Types.ImportMovethewheelsDataMutation>;
+export type ImportMovethewheelsDataMutationOptions = Apollo.BaseMutationOptions<Types.ImportMovethewheelsDataMutation, Types.ImportMovethewheelsDataMutationVariables>;
+export const ExportMovethewheelsDataDocument = gql`
+    mutation ExportMovethewheelsData($input: MovethewheelsExportDataInput!) {
+  exportData(input: $input) {
+    success
+    message
+    payload
+  }
+}
+    `;
+export type ExportMovethewheelsDataMutationFn = Apollo.MutationFunction<Types.ExportMovethewheelsDataMutation, Types.ExportMovethewheelsDataMutationVariables>;
+
+/**
+ * __useExportMovethewheelsDataMutation__
+ *
+ * To run a mutation, you first call `useExportMovethewheelsDataMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useExportMovethewheelsDataMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [exportMovethewheelsDataMutation, { data, loading, error }] = useExportMovethewheelsDataMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useExportMovethewheelsDataMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ExportMovethewheelsDataMutation, Types.ExportMovethewheelsDataMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.ExportMovethewheelsDataMutation, Types.ExportMovethewheelsDataMutationVariables>(ExportMovethewheelsDataDocument, options);
+      }
+export type ExportMovethewheelsDataMutationHookResult = ReturnType<typeof useExportMovethewheelsDataMutation>;
+export type ExportMovethewheelsDataMutationResult = Apollo.MutationResult<Types.ExportMovethewheelsDataMutation>;
+export type ExportMovethewheelsDataMutationOptions = Apollo.BaseMutationOptions<Types.ExportMovethewheelsDataMutation, Types.ExportMovethewheelsDataMutationVariables>;
+export const UpdateMovethewheelsModuleSettingsDocument = gql`
+    mutation UpdateMovethewheelsModuleSettings($input: UpdateMovethewheelsModuleSettingsInput!) {
+  updateModuleSettings(input: $input) {
+    workspaceId
+    preferences
+    updatedAt
+  }
+}
+    `;
+export type UpdateMovethewheelsModuleSettingsMutationFn = Apollo.MutationFunction<Types.UpdateMovethewheelsModuleSettingsMutation, Types.UpdateMovethewheelsModuleSettingsMutationVariables>;
+
+/**
+ * __useUpdateMovethewheelsModuleSettingsMutation__
+ *
+ * To run a mutation, you first call `useUpdateMovethewheelsModuleSettingsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateMovethewheelsModuleSettingsMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateMovethewheelsModuleSettingsMutation, { data, loading, error }] = useUpdateMovethewheelsModuleSettingsMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateMovethewheelsModuleSettingsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateMovethewheelsModuleSettingsMutation, Types.UpdateMovethewheelsModuleSettingsMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateMovethewheelsModuleSettingsMutation, Types.UpdateMovethewheelsModuleSettingsMutationVariables>(UpdateMovethewheelsModuleSettingsDocument, options);
+      }
+export type UpdateMovethewheelsModuleSettingsMutationHookResult = ReturnType<typeof useUpdateMovethewheelsModuleSettingsMutation>;
+export type UpdateMovethewheelsModuleSettingsMutationResult = Apollo.MutationResult<Types.UpdateMovethewheelsModuleSettingsMutation>;
+export type UpdateMovethewheelsModuleSettingsMutationOptions = Apollo.BaseMutationOptions<Types.UpdateMovethewheelsModuleSettingsMutation, Types.UpdateMovethewheelsModuleSettingsMutationVariables>;
+export const CreateMovethewheelsOrderDocument = gql`
+    mutation CreateMovethewheelsOrder($input: CreateOrderInput!) {
+  createMovethewheelsOrder(input: $input) {
+    ...MovethewheelsOrderCore
+  }
+}
+    ${MovethewheelsOrderCoreFragmentDoc}`;
+export type CreateMovethewheelsOrderMutationFn = Apollo.MutationFunction<Types.CreateMovethewheelsOrderMutation, Types.CreateMovethewheelsOrderMutationVariables>;
+
+/**
+ * __useCreateMovethewheelsOrderMutation__
+ *
+ * To run a mutation, you first call `useCreateMovethewheelsOrderMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateMovethewheelsOrderMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createMovethewheelsOrderMutation, { data, loading, error }] = useCreateMovethewheelsOrderMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateMovethewheelsOrderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateMovethewheelsOrderMutation, Types.CreateMovethewheelsOrderMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.CreateMovethewheelsOrderMutation, Types.CreateMovethewheelsOrderMutationVariables>(CreateMovethewheelsOrderDocument, options);
+      }
+export type CreateMovethewheelsOrderMutationHookResult = ReturnType<typeof useCreateMovethewheelsOrderMutation>;
+export type CreateMovethewheelsOrderMutationResult = Apollo.MutationResult<Types.CreateMovethewheelsOrderMutation>;
+export type CreateMovethewheelsOrderMutationOptions = Apollo.BaseMutationOptions<Types.CreateMovethewheelsOrderMutation, Types.CreateMovethewheelsOrderMutationVariables>;
+export const UpdateMovethewheelsOrderDocument = gql`
+    mutation UpdateMovethewheelsOrder($id: ID!, $input: UpdateOrderInput!) {
+  updateMovethewheelsOrder(id: $id, input: $input) {
+    ...MovethewheelsOrderCore
+  }
+}
+    ${MovethewheelsOrderCoreFragmentDoc}`;
+export type UpdateMovethewheelsOrderMutationFn = Apollo.MutationFunction<Types.UpdateMovethewheelsOrderMutation, Types.UpdateMovethewheelsOrderMutationVariables>;
+
+/**
+ * __useUpdateMovethewheelsOrderMutation__
+ *
+ * To run a mutation, you first call `useUpdateMovethewheelsOrderMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateMovethewheelsOrderMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateMovethewheelsOrderMutation, { data, loading, error }] = useUpdateMovethewheelsOrderMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateMovethewheelsOrderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateMovethewheelsOrderMutation, Types.UpdateMovethewheelsOrderMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateMovethewheelsOrderMutation, Types.UpdateMovethewheelsOrderMutationVariables>(UpdateMovethewheelsOrderDocument, options);
+      }
+export type UpdateMovethewheelsOrderMutationHookResult = ReturnType<typeof useUpdateMovethewheelsOrderMutation>;
+export type UpdateMovethewheelsOrderMutationResult = Apollo.MutationResult<Types.UpdateMovethewheelsOrderMutation>;
+export type UpdateMovethewheelsOrderMutationOptions = Apollo.BaseMutationOptions<Types.UpdateMovethewheelsOrderMutation, Types.UpdateMovethewheelsOrderMutationVariables>;
+export const UpdateMovethewheelsOrderStatusDocument = gql`
+    mutation UpdateMovethewheelsOrderStatus($id: ID!, $input: UpdateOrderStatusInput!) {
+  updateMovethewheelsOrderStatus(id: $id, input: $input) {
+    ...MovethewheelsOrderCore
+  }
+}
+    ${MovethewheelsOrderCoreFragmentDoc}`;
+export type UpdateMovethewheelsOrderStatusMutationFn = Apollo.MutationFunction<Types.UpdateMovethewheelsOrderStatusMutation, Types.UpdateMovethewheelsOrderStatusMutationVariables>;
+
+/**
+ * __useUpdateMovethewheelsOrderStatusMutation__
+ *
+ * To run a mutation, you first call `useUpdateMovethewheelsOrderStatusMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateMovethewheelsOrderStatusMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateMovethewheelsOrderStatusMutation, { data, loading, error }] = useUpdateMovethewheelsOrderStatusMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useUpdateMovethewheelsOrderStatusMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateMovethewheelsOrderStatusMutation, Types.UpdateMovethewheelsOrderStatusMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.UpdateMovethewheelsOrderStatusMutation, Types.UpdateMovethewheelsOrderStatusMutationVariables>(UpdateMovethewheelsOrderStatusDocument, options);
+      }
+export type UpdateMovethewheelsOrderStatusMutationHookResult = ReturnType<typeof useUpdateMovethewheelsOrderStatusMutation>;
+export type UpdateMovethewheelsOrderStatusMutationResult = Apollo.MutationResult<Types.UpdateMovethewheelsOrderStatusMutation>;
+export type UpdateMovethewheelsOrderStatusMutationOptions = Apollo.BaseMutationOptions<Types.UpdateMovethewheelsOrderStatusMutation, Types.UpdateMovethewheelsOrderStatusMutationVariables>;
+export const DeleteMovethewheelsOrderDocument = gql`
+    mutation DeleteMovethewheelsOrder($id: ID!) {
+  deleteMovethewheelsOrder(id: $id)
+}
+    `;
+export type DeleteMovethewheelsOrderMutationFn = Apollo.MutationFunction<Types.DeleteMovethewheelsOrderMutation, Types.DeleteMovethewheelsOrderMutationVariables>;
+
+/**
+ * __useDeleteMovethewheelsOrderMutation__
+ *
+ * To run a mutation, you first call `useDeleteMovethewheelsOrderMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteMovethewheelsOrderMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [deleteMovethewheelsOrderMutation, { data, loading, error }] = useDeleteMovethewheelsOrderMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useDeleteMovethewheelsOrderMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteMovethewheelsOrderMutation, Types.DeleteMovethewheelsOrderMutationVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useMutation<Types.DeleteMovethewheelsOrderMutation, Types.DeleteMovethewheelsOrderMutationVariables>(DeleteMovethewheelsOrderDocument, options);
+      }
+export type DeleteMovethewheelsOrderMutationHookResult = ReturnType<typeof useDeleteMovethewheelsOrderMutation>;
+export type DeleteMovethewheelsOrderMutationResult = Apollo.MutationResult<Types.DeleteMovethewheelsOrderMutation>;
+export type DeleteMovethewheelsOrderMutationOptions = Apollo.BaseMutationOptions<Types.DeleteMovethewheelsOrderMutation, Types.DeleteMovethewheelsOrderMutationVariables>;
+export const GetMovethewheelsDashboardDocument = gql`
+    query GetMovethewheelsDashboard {
+  dashboardMetrics {
+    totalOrders
+    activeDeliveries
+    availableDrivers
+    activeVehicles
+    lowStockItems
+    totalRevenue
+    recentOrders {
+      ...MovethewheelsOrderCore
+    }
+  }
+  orderStats {
+    total
+    pending
+    inTransit
+    delivered
+    cancelled
+    failed
+  }
+  fleetStats {
+    totalVehicles
+    activeVehicles
+    inTransitVehicles
+    maintenanceVehicles
+    totalDrivers
+    availableDrivers
+    onDeliveryDrivers
+  }
+  financeMetrics {
+    fuelCost
+    openInvoices
+    revenue {
+      totalRevenue
+      averageOrderValue
+      deliveredRevenue
+    }
+  }
+  analytics {
+    deliveryTrend {
+      label
+      value
+    }
+    orderTrend {
+      label
+      value
+    }
+    revenueTrend {
+      label
+      value
+    }
+  }
+}
+    ${MovethewheelsOrderCoreFragmentDoc}`;
+
+/**
+ * __useGetMovethewheelsDashboardQuery__
+ *
+ * To run a query within a React component, call `useGetMovethewheelsDashboardQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMovethewheelsDashboardQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetMovethewheelsDashboardQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useGetMovethewheelsDashboardQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetMovethewheelsDashboardQuery, Types.GetMovethewheelsDashboardQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetMovethewheelsDashboardQuery, Types.GetMovethewheelsDashboardQueryVariables>(GetMovethewheelsDashboardDocument, options);
+      }
+export function useGetMovethewheelsDashboardLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMovethewheelsDashboardQuery, Types.GetMovethewheelsDashboardQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetMovethewheelsDashboardQuery, Types.GetMovethewheelsDashboardQueryVariables>(GetMovethewheelsDashboardDocument, options);
+        }
+// @ts-ignore
+export function useGetMovethewheelsDashboardSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMovethewheelsDashboardQuery, Types.GetMovethewheelsDashboardQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMovethewheelsDashboardQuery, Types.GetMovethewheelsDashboardQueryVariables>;
+export function useGetMovethewheelsDashboardSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMovethewheelsDashboardQuery, Types.GetMovethewheelsDashboardQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMovethewheelsDashboardQuery | undefined, Types.GetMovethewheelsDashboardQueryVariables>;
+export function useGetMovethewheelsDashboardSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMovethewheelsDashboardQuery, Types.GetMovethewheelsDashboardQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetMovethewheelsDashboardQuery, Types.GetMovethewheelsDashboardQueryVariables>(GetMovethewheelsDashboardDocument, options);
+        }
+export type GetMovethewheelsDashboardQueryHookResult = ReturnType<typeof useGetMovethewheelsDashboardQuery>;
+export type GetMovethewheelsDashboardLazyQueryHookResult = ReturnType<typeof useGetMovethewheelsDashboardLazyQuery>;
+export type GetMovethewheelsDashboardSuspenseQueryHookResult = ReturnType<typeof useGetMovethewheelsDashboardSuspenseQuery>;
+export type GetMovethewheelsDashboardQueryResult = Apollo.QueryResult<Types.GetMovethewheelsDashboardQuery, Types.GetMovethewheelsDashboardQueryVariables>;
+export const GetAssistantInsightsDocument = gql`
+    query GetAssistantInsights($question: String!) {
+  assistantInsights(question: $question) {
+    question
+    answer
+    generatedAt
+  }
+}
+    `;
+
+/**
+ * __useGetAssistantInsightsQuery__
+ *
+ * To run a query within a React component, call `useGetAssistantInsightsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetAssistantInsightsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetAssistantInsightsQuery({
+ *   variables: {
+ *      question: // value for 'question'
+ *   },
+ * });
+ */
+export function useGetAssistantInsightsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetAssistantInsightsQuery, Types.GetAssistantInsightsQueryVariables> & ({ variables: Types.GetAssistantInsightsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetAssistantInsightsQuery, Types.GetAssistantInsightsQueryVariables>(GetAssistantInsightsDocument, options);
+      }
+export function useGetAssistantInsightsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetAssistantInsightsQuery, Types.GetAssistantInsightsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetAssistantInsightsQuery, Types.GetAssistantInsightsQueryVariables>(GetAssistantInsightsDocument, options);
+        }
+// @ts-ignore
+export function useGetAssistantInsightsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAssistantInsightsQuery, Types.GetAssistantInsightsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAssistantInsightsQuery, Types.GetAssistantInsightsQueryVariables>;
+export function useGetAssistantInsightsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAssistantInsightsQuery, Types.GetAssistantInsightsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAssistantInsightsQuery | undefined, Types.GetAssistantInsightsQueryVariables>;
+export function useGetAssistantInsightsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAssistantInsightsQuery, Types.GetAssistantInsightsQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetAssistantInsightsQuery, Types.GetAssistantInsightsQueryVariables>(GetAssistantInsightsDocument, options);
+        }
+export type GetAssistantInsightsQueryHookResult = ReturnType<typeof useGetAssistantInsightsQuery>;
+export type GetAssistantInsightsLazyQueryHookResult = ReturnType<typeof useGetAssistantInsightsLazyQuery>;
+export type GetAssistantInsightsSuspenseQueryHookResult = ReturnType<typeof useGetAssistantInsightsSuspenseQuery>;
+export type GetAssistantInsightsQueryResult = Apollo.QueryResult<Types.GetAssistantInsightsQuery, Types.GetAssistantInsightsQueryVariables>;
+export const ListCustomersDocument = gql`
+    query ListCustomers($filter: CustomerFilterInput, $pagination: PaginationInput) {
+  customers(filter: $filter, pagination: $pagination) {
+    ...CustomerCore
+  }
+}
+    ${CustomerCoreFragmentDoc}`;
+
+/**
+ * __useListCustomersQuery__
+ *
+ * To run a query within a React component, call `useListCustomersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListCustomersQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useListCustomersQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export function useListCustomersQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListCustomersQuery, Types.ListCustomersQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.ListCustomersQuery, Types.ListCustomersQueryVariables>(ListCustomersDocument, options);
+      }
+export function useListCustomersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListCustomersQuery, Types.ListCustomersQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.ListCustomersQuery, Types.ListCustomersQueryVariables>(ListCustomersDocument, options);
+        }
+// @ts-ignore
+export function useListCustomersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListCustomersQuery, Types.ListCustomersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListCustomersQuery, Types.ListCustomersQueryVariables>;
+export function useListCustomersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListCustomersQuery, Types.ListCustomersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListCustomersQuery | undefined, Types.ListCustomersQueryVariables>;
+export function useListCustomersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListCustomersQuery, Types.ListCustomersQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.ListCustomersQuery, Types.ListCustomersQueryVariables>(ListCustomersDocument, options);
+        }
+export type ListCustomersQueryHookResult = ReturnType<typeof useListCustomersQuery>;
+export type ListCustomersLazyQueryHookResult = ReturnType<typeof useListCustomersLazyQuery>;
+export type ListCustomersSuspenseQueryHookResult = ReturnType<typeof useListCustomersSuspenseQuery>;
+export type ListCustomersQueryResult = Apollo.QueryResult<Types.ListCustomersQuery, Types.ListCustomersQueryVariables>;
+export const GetCustomerDocument = gql`
+    query GetCustomer($id: ID!) {
+  customer(id: $id) {
+    ...CustomerCore
+  }
+}
+    ${CustomerCoreFragmentDoc}`;
+
+/**
+ * __useGetCustomerQuery__
+ *
+ * To run a query within a React component, call `useGetCustomerQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetCustomerQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetCustomerQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetCustomerQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetCustomerQuery, Types.GetCustomerQueryVariables> & ({ variables: Types.GetCustomerQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetCustomerQuery, Types.GetCustomerQueryVariables>(GetCustomerDocument, options);
+      }
+export function useGetCustomerLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetCustomerQuery, Types.GetCustomerQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetCustomerQuery, Types.GetCustomerQueryVariables>(GetCustomerDocument, options);
+        }
+// @ts-ignore
+export function useGetCustomerSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetCustomerQuery, Types.GetCustomerQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetCustomerQuery, Types.GetCustomerQueryVariables>;
+export function useGetCustomerSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetCustomerQuery, Types.GetCustomerQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetCustomerQuery | undefined, Types.GetCustomerQueryVariables>;
+export function useGetCustomerSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetCustomerQuery, Types.GetCustomerQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetCustomerQuery, Types.GetCustomerQueryVariables>(GetCustomerDocument, options);
+        }
+export type GetCustomerQueryHookResult = ReturnType<typeof useGetCustomerQuery>;
+export type GetCustomerLazyQueryHookResult = ReturnType<typeof useGetCustomerLazyQuery>;
+export type GetCustomerSuspenseQueryHookResult = ReturnType<typeof useGetCustomerSuspenseQuery>;
+export type GetCustomerQueryResult = Apollo.QueryResult<Types.GetCustomerQuery, Types.GetCustomerQueryVariables>;
+export const ListProductsDocument = gql`
+    query ListProducts($filter: ProductFilterInput, $pagination: PaginationInput) {
+  products(filter: $filter, pagination: $pagination) {
+    ...ProductCore
+  }
+}
+    ${ProductCoreFragmentDoc}`;
+
+/**
+ * __useListProductsQuery__
+ *
+ * To run a query within a React component, call `useListProductsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListProductsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useListProductsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export function useListProductsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListProductsQuery, Types.ListProductsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.ListProductsQuery, Types.ListProductsQueryVariables>(ListProductsDocument, options);
+      }
+export function useListProductsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListProductsQuery, Types.ListProductsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.ListProductsQuery, Types.ListProductsQueryVariables>(ListProductsDocument, options);
+        }
+// @ts-ignore
+export function useListProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListProductsQuery, Types.ListProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListProductsQuery, Types.ListProductsQueryVariables>;
+export function useListProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListProductsQuery, Types.ListProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListProductsQuery | undefined, Types.ListProductsQueryVariables>;
+export function useListProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListProductsQuery, Types.ListProductsQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.ListProductsQuery, Types.ListProductsQueryVariables>(ListProductsDocument, options);
+        }
+export type ListProductsQueryHookResult = ReturnType<typeof useListProductsQuery>;
+export type ListProductsLazyQueryHookResult = ReturnType<typeof useListProductsLazyQuery>;
+export type ListProductsSuspenseQueryHookResult = ReturnType<typeof useListProductsSuspenseQuery>;
+export type ListProductsQueryResult = Apollo.QueryResult<Types.ListProductsQuery, Types.ListProductsQueryVariables>;
+export const GetProductDocument = gql`
+    query GetProduct($id: ID!) {
+  product(id: $id) {
+    ...ProductCore
+  }
+}
+    ${ProductCoreFragmentDoc}`;
+
+/**
+ * __useGetProductQuery__
+ *
+ * To run a query within a React component, call `useGetProductQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetProductQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetProductQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetProductQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetProductQuery, Types.GetProductQueryVariables> & ({ variables: Types.GetProductQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetProductQuery, Types.GetProductQueryVariables>(GetProductDocument, options);
+      }
+export function useGetProductLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetProductQuery, Types.GetProductQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetProductQuery, Types.GetProductQueryVariables>(GetProductDocument, options);
+        }
+// @ts-ignore
+export function useGetProductSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProductQuery, Types.GetProductQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProductQuery, Types.GetProductQueryVariables>;
+export function useGetProductSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProductQuery, Types.GetProductQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProductQuery | undefined, Types.GetProductQueryVariables>;
+export function useGetProductSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProductQuery, Types.GetProductQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetProductQuery, Types.GetProductQueryVariables>(GetProductDocument, options);
+        }
+export type GetProductQueryHookResult = ReturnType<typeof useGetProductQuery>;
+export type GetProductLazyQueryHookResult = ReturnType<typeof useGetProductLazyQuery>;
+export type GetProductSuspenseQueryHookResult = ReturnType<typeof useGetProductSuspenseQuery>;
+export type GetProductQueryResult = Apollo.QueryResult<Types.GetProductQuery, Types.GetProductQueryVariables>;
+export const ListVehiclesDocument = gql`
+    query ListVehicles($filter: VehicleFilterInput, $pagination: PaginationInput) {
+  vehicles(filter: $filter, pagination: $pagination) {
+    ...VehicleCore
+  }
+}
+    ${VehicleCoreFragmentDoc}`;
+
+/**
+ * __useListVehiclesQuery__
+ *
+ * To run a query within a React component, call `useListVehiclesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListVehiclesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useListVehiclesQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export function useListVehiclesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListVehiclesQuery, Types.ListVehiclesQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.ListVehiclesQuery, Types.ListVehiclesQueryVariables>(ListVehiclesDocument, options);
+      }
+export function useListVehiclesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListVehiclesQuery, Types.ListVehiclesQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.ListVehiclesQuery, Types.ListVehiclesQueryVariables>(ListVehiclesDocument, options);
+        }
+// @ts-ignore
+export function useListVehiclesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListVehiclesQuery, Types.ListVehiclesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListVehiclesQuery, Types.ListVehiclesQueryVariables>;
+export function useListVehiclesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListVehiclesQuery, Types.ListVehiclesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListVehiclesQuery | undefined, Types.ListVehiclesQueryVariables>;
+export function useListVehiclesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListVehiclesQuery, Types.ListVehiclesQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.ListVehiclesQuery, Types.ListVehiclesQueryVariables>(ListVehiclesDocument, options);
+        }
+export type ListVehiclesQueryHookResult = ReturnType<typeof useListVehiclesQuery>;
+export type ListVehiclesLazyQueryHookResult = ReturnType<typeof useListVehiclesLazyQuery>;
+export type ListVehiclesSuspenseQueryHookResult = ReturnType<typeof useListVehiclesSuspenseQuery>;
+export type ListVehiclesQueryResult = Apollo.QueryResult<Types.ListVehiclesQuery, Types.ListVehiclesQueryVariables>;
+export const GetVehicleDocument = gql`
+    query GetVehicle($id: ID!) {
+  vehicle(id: $id) {
+    ...VehicleCore
+  }
+}
+    ${VehicleCoreFragmentDoc}`;
+
+/**
+ * __useGetVehicleQuery__
+ *
+ * To run a query within a React component, call `useGetVehicleQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetVehicleQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetVehicleQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetVehicleQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetVehicleQuery, Types.GetVehicleQueryVariables> & ({ variables: Types.GetVehicleQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetVehicleQuery, Types.GetVehicleQueryVariables>(GetVehicleDocument, options);
+      }
+export function useGetVehicleLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetVehicleQuery, Types.GetVehicleQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetVehicleQuery, Types.GetVehicleQueryVariables>(GetVehicleDocument, options);
+        }
+// @ts-ignore
+export function useGetVehicleSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetVehicleQuery, Types.GetVehicleQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetVehicleQuery, Types.GetVehicleQueryVariables>;
+export function useGetVehicleSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetVehicleQuery, Types.GetVehicleQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetVehicleQuery | undefined, Types.GetVehicleQueryVariables>;
+export function useGetVehicleSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetVehicleQuery, Types.GetVehicleQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetVehicleQuery, Types.GetVehicleQueryVariables>(GetVehicleDocument, options);
+        }
+export type GetVehicleQueryHookResult = ReturnType<typeof useGetVehicleQuery>;
+export type GetVehicleLazyQueryHookResult = ReturnType<typeof useGetVehicleLazyQuery>;
+export type GetVehicleSuspenseQueryHookResult = ReturnType<typeof useGetVehicleSuspenseQuery>;
+export type GetVehicleQueryResult = Apollo.QueryResult<Types.GetVehicleQuery, Types.GetVehicleQueryVariables>;
+export const ListDriversDocument = gql`
+    query ListDrivers($filter: DriverFilterInput, $pagination: PaginationInput) {
+  drivers(filter: $filter, pagination: $pagination) {
+    ...DriverCore
+  }
+}
+    ${DriverCoreFragmentDoc}`;
+
+/**
+ * __useListDriversQuery__
+ *
+ * To run a query within a React component, call `useListDriversQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListDriversQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useListDriversQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export function useListDriversQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListDriversQuery, Types.ListDriversQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.ListDriversQuery, Types.ListDriversQueryVariables>(ListDriversDocument, options);
+      }
+export function useListDriversLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListDriversQuery, Types.ListDriversQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.ListDriversQuery, Types.ListDriversQueryVariables>(ListDriversDocument, options);
+        }
+// @ts-ignore
+export function useListDriversSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListDriversQuery, Types.ListDriversQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListDriversQuery, Types.ListDriversQueryVariables>;
+export function useListDriversSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListDriversQuery, Types.ListDriversQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListDriversQuery | undefined, Types.ListDriversQueryVariables>;
+export function useListDriversSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListDriversQuery, Types.ListDriversQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.ListDriversQuery, Types.ListDriversQueryVariables>(ListDriversDocument, options);
+        }
+export type ListDriversQueryHookResult = ReturnType<typeof useListDriversQuery>;
+export type ListDriversLazyQueryHookResult = ReturnType<typeof useListDriversLazyQuery>;
+export type ListDriversSuspenseQueryHookResult = ReturnType<typeof useListDriversSuspenseQuery>;
+export type ListDriversQueryResult = Apollo.QueryResult<Types.ListDriversQuery, Types.ListDriversQueryVariables>;
+export const GetDriverDocument = gql`
+    query GetDriver($id: ID!) {
+  driver(id: $id) {
+    ...DriverCore
+  }
+}
+    ${DriverCoreFragmentDoc}`;
+
+/**
+ * __useGetDriverQuery__
+ *
+ * To run a query within a React component, call `useGetDriverQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetDriverQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetDriverQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetDriverQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetDriverQuery, Types.GetDriverQueryVariables> & ({ variables: Types.GetDriverQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetDriverQuery, Types.GetDriverQueryVariables>(GetDriverDocument, options);
+      }
+export function useGetDriverLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetDriverQuery, Types.GetDriverQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetDriverQuery, Types.GetDriverQueryVariables>(GetDriverDocument, options);
+        }
+// @ts-ignore
+export function useGetDriverSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDriverQuery, Types.GetDriverQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDriverQuery, Types.GetDriverQueryVariables>;
+export function useGetDriverSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDriverQuery, Types.GetDriverQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetDriverQuery | undefined, Types.GetDriverQueryVariables>;
+export function useGetDriverSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetDriverQuery, Types.GetDriverQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetDriverQuery, Types.GetDriverQueryVariables>(GetDriverDocument, options);
+        }
+export type GetDriverQueryHookResult = ReturnType<typeof useGetDriverQuery>;
+export type GetDriverLazyQueryHookResult = ReturnType<typeof useGetDriverLazyQuery>;
+export type GetDriverSuspenseQueryHookResult = ReturnType<typeof useGetDriverSuspenseQuery>;
+export type GetDriverQueryResult = Apollo.QueryResult<Types.GetDriverQuery, Types.GetDriverQueryVariables>;
+export const ListWarehousesDocument = gql`
+    query ListWarehouses($filter: WarehouseFilterInput, $pagination: PaginationInput) {
+  warehouses(filter: $filter, pagination: $pagination) {
+    ...WarehouseCore
+    locations {
+      id
+      locationCode
+      zone
+      aisle
+      rack
+      shelf
+      bin
+      locationType
+      capacity
+      status
+    }
+  }
+}
+    ${WarehouseCoreFragmentDoc}`;
+
+/**
+ * __useListWarehousesQuery__
+ *
+ * To run a query within a React component, call `useListWarehousesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListWarehousesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useListWarehousesQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export function useListWarehousesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListWarehousesQuery, Types.ListWarehousesQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.ListWarehousesQuery, Types.ListWarehousesQueryVariables>(ListWarehousesDocument, options);
+      }
+export function useListWarehousesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListWarehousesQuery, Types.ListWarehousesQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.ListWarehousesQuery, Types.ListWarehousesQueryVariables>(ListWarehousesDocument, options);
+        }
+// @ts-ignore
+export function useListWarehousesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListWarehousesQuery, Types.ListWarehousesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListWarehousesQuery, Types.ListWarehousesQueryVariables>;
+export function useListWarehousesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListWarehousesQuery, Types.ListWarehousesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListWarehousesQuery | undefined, Types.ListWarehousesQueryVariables>;
+export function useListWarehousesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListWarehousesQuery, Types.ListWarehousesQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.ListWarehousesQuery, Types.ListWarehousesQueryVariables>(ListWarehousesDocument, options);
+        }
+export type ListWarehousesQueryHookResult = ReturnType<typeof useListWarehousesQuery>;
+export type ListWarehousesLazyQueryHookResult = ReturnType<typeof useListWarehousesLazyQuery>;
+export type ListWarehousesSuspenseQueryHookResult = ReturnType<typeof useListWarehousesSuspenseQuery>;
+export type ListWarehousesQueryResult = Apollo.QueryResult<Types.ListWarehousesQuery, Types.ListWarehousesQueryVariables>;
+export const GetWarehouseDocument = gql`
+    query GetWarehouse($id: ID!) {
+  warehouse(id: $id) {
+    ...WarehouseCore
+    locations {
+      id
+      locationCode
+      zone
+      aisle
+      rack
+      shelf
+      bin
+      locationType
+      capacity
+      status
+    }
+  }
+}
+    ${WarehouseCoreFragmentDoc}`;
+
+/**
+ * __useGetWarehouseQuery__
+ *
+ * To run a query within a React component, call `useGetWarehouseQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWarehouseQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetWarehouseQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetWarehouseQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetWarehouseQuery, Types.GetWarehouseQueryVariables> & ({ variables: Types.GetWarehouseQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetWarehouseQuery, Types.GetWarehouseQueryVariables>(GetWarehouseDocument, options);
+      }
+export function useGetWarehouseLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWarehouseQuery, Types.GetWarehouseQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetWarehouseQuery, Types.GetWarehouseQueryVariables>(GetWarehouseDocument, options);
+        }
+// @ts-ignore
+export function useGetWarehouseSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWarehouseQuery, Types.GetWarehouseQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWarehouseQuery, Types.GetWarehouseQueryVariables>;
+export function useGetWarehouseSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWarehouseQuery, Types.GetWarehouseQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWarehouseQuery | undefined, Types.GetWarehouseQueryVariables>;
+export function useGetWarehouseSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWarehouseQuery, Types.GetWarehouseQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetWarehouseQuery, Types.GetWarehouseQueryVariables>(GetWarehouseDocument, options);
+        }
+export type GetWarehouseQueryHookResult = ReturnType<typeof useGetWarehouseQuery>;
+export type GetWarehouseLazyQueryHookResult = ReturnType<typeof useGetWarehouseLazyQuery>;
+export type GetWarehouseSuspenseQueryHookResult = ReturnType<typeof useGetWarehouseSuspenseQuery>;
+export type GetWarehouseQueryResult = Apollo.QueryResult<Types.GetWarehouseQuery, Types.GetWarehouseQueryVariables>;
+export const ListInventoryItemsDocument = gql`
+    query ListInventoryItems($filter: InventoryFilterInput, $pagination: PaginationInput) {
+  inventoryItems(filter: $filter, pagination: $pagination) {
+    ...InventoryItemCore
+    product {
+      id
+      name
+      sku
+      category
+    }
+    warehouse {
+      id
+      name
+      code
+      type
+    }
+  }
+}
+    ${InventoryItemCoreFragmentDoc}`;
+
+/**
+ * __useListInventoryItemsQuery__
+ *
+ * To run a query within a React component, call `useListInventoryItemsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListInventoryItemsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useListInventoryItemsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export function useListInventoryItemsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListInventoryItemsQuery, Types.ListInventoryItemsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.ListInventoryItemsQuery, Types.ListInventoryItemsQueryVariables>(ListInventoryItemsDocument, options);
+      }
+export function useListInventoryItemsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListInventoryItemsQuery, Types.ListInventoryItemsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.ListInventoryItemsQuery, Types.ListInventoryItemsQueryVariables>(ListInventoryItemsDocument, options);
+        }
+// @ts-ignore
+export function useListInventoryItemsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListInventoryItemsQuery, Types.ListInventoryItemsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListInventoryItemsQuery, Types.ListInventoryItemsQueryVariables>;
+export function useListInventoryItemsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListInventoryItemsQuery, Types.ListInventoryItemsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListInventoryItemsQuery | undefined, Types.ListInventoryItemsQueryVariables>;
+export function useListInventoryItemsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListInventoryItemsQuery, Types.ListInventoryItemsQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.ListInventoryItemsQuery, Types.ListInventoryItemsQueryVariables>(ListInventoryItemsDocument, options);
+        }
+export type ListInventoryItemsQueryHookResult = ReturnType<typeof useListInventoryItemsQuery>;
+export type ListInventoryItemsLazyQueryHookResult = ReturnType<typeof useListInventoryItemsLazyQuery>;
+export type ListInventoryItemsSuspenseQueryHookResult = ReturnType<typeof useListInventoryItemsSuspenseQuery>;
+export type ListInventoryItemsQueryResult = Apollo.QueryResult<Types.ListInventoryItemsQuery, Types.ListInventoryItemsQueryVariables>;
+export const GetInventoryStatsDocument = gql`
+    query GetInventoryStats {
+  inventoryStats {
+    totalOnHand
+    totalAvailable
+    totalAllocated
+    totalDamaged
+    lowStockCount
+  }
+}
+    `;
+
+/**
+ * __useGetInventoryStatsQuery__
+ *
+ * To run a query within a React component, call `useGetInventoryStatsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetInventoryStatsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetInventoryStatsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useGetInventoryStatsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetInventoryStatsQuery, Types.GetInventoryStatsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetInventoryStatsQuery, Types.GetInventoryStatsQueryVariables>(GetInventoryStatsDocument, options);
+      }
+export function useGetInventoryStatsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetInventoryStatsQuery, Types.GetInventoryStatsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetInventoryStatsQuery, Types.GetInventoryStatsQueryVariables>(GetInventoryStatsDocument, options);
+        }
+// @ts-ignore
+export function useGetInventoryStatsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetInventoryStatsQuery, Types.GetInventoryStatsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetInventoryStatsQuery, Types.GetInventoryStatsQueryVariables>;
+export function useGetInventoryStatsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetInventoryStatsQuery, Types.GetInventoryStatsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetInventoryStatsQuery | undefined, Types.GetInventoryStatsQueryVariables>;
+export function useGetInventoryStatsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetInventoryStatsQuery, Types.GetInventoryStatsQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetInventoryStatsQuery, Types.GetInventoryStatsQueryVariables>(GetInventoryStatsDocument, options);
+        }
+export type GetInventoryStatsQueryHookResult = ReturnType<typeof useGetInventoryStatsQuery>;
+export type GetInventoryStatsLazyQueryHookResult = ReturnType<typeof useGetInventoryStatsLazyQuery>;
+export type GetInventoryStatsSuspenseQueryHookResult = ReturnType<typeof useGetInventoryStatsSuspenseQuery>;
+export type GetInventoryStatsQueryResult = Apollo.QueryResult<Types.GetInventoryStatsQuery, Types.GetInventoryStatsQueryVariables>;
+export const ListRoutesDocument = gql`
+    query ListRoutes($filter: RouteFilterInput, $pagination: PaginationInput) {
+  routes(filter: $filter, pagination: $pagination) {
+    ...RouteCore
+  }
+}
+    ${RouteCoreFragmentDoc}`;
+
+/**
+ * __useListRoutesQuery__
+ *
+ * To run a query within a React component, call `useListRoutesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListRoutesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useListRoutesQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export function useListRoutesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListRoutesQuery, Types.ListRoutesQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.ListRoutesQuery, Types.ListRoutesQueryVariables>(ListRoutesDocument, options);
+      }
+export function useListRoutesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListRoutesQuery, Types.ListRoutesQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.ListRoutesQuery, Types.ListRoutesQueryVariables>(ListRoutesDocument, options);
+        }
+// @ts-ignore
+export function useListRoutesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListRoutesQuery, Types.ListRoutesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListRoutesQuery, Types.ListRoutesQueryVariables>;
+export function useListRoutesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListRoutesQuery, Types.ListRoutesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListRoutesQuery | undefined, Types.ListRoutesQueryVariables>;
+export function useListRoutesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListRoutesQuery, Types.ListRoutesQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.ListRoutesQuery, Types.ListRoutesQueryVariables>(ListRoutesDocument, options);
+        }
+export type ListRoutesQueryHookResult = ReturnType<typeof useListRoutesQuery>;
+export type ListRoutesLazyQueryHookResult = ReturnType<typeof useListRoutesLazyQuery>;
+export type ListRoutesSuspenseQueryHookResult = ReturnType<typeof useListRoutesSuspenseQuery>;
+export type ListRoutesQueryResult = Apollo.QueryResult<Types.ListRoutesQuery, Types.ListRoutesQueryVariables>;
+export const GetRouteDocument = gql`
+    query GetRoute($id: ID!) {
+  route(id: $id) {
+    ...RouteCore
+  }
+}
+    ${RouteCoreFragmentDoc}`;
+
+/**
+ * __useGetRouteQuery__
+ *
+ * To run a query within a React component, call `useGetRouteQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetRouteQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetRouteQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetRouteQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetRouteQuery, Types.GetRouteQueryVariables> & ({ variables: Types.GetRouteQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetRouteQuery, Types.GetRouteQueryVariables>(GetRouteDocument, options);
+      }
+export function useGetRouteLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetRouteQuery, Types.GetRouteQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetRouteQuery, Types.GetRouteQueryVariables>(GetRouteDocument, options);
+        }
+// @ts-ignore
+export function useGetRouteSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetRouteQuery, Types.GetRouteQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetRouteQuery, Types.GetRouteQueryVariables>;
+export function useGetRouteSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetRouteQuery, Types.GetRouteQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetRouteQuery | undefined, Types.GetRouteQueryVariables>;
+export function useGetRouteSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetRouteQuery, Types.GetRouteQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetRouteQuery, Types.GetRouteQueryVariables>(GetRouteDocument, options);
+        }
+export type GetRouteQueryHookResult = ReturnType<typeof useGetRouteQuery>;
+export type GetRouteLazyQueryHookResult = ReturnType<typeof useGetRouteLazyQuery>;
+export type GetRouteSuspenseQueryHookResult = ReturnType<typeof useGetRouteSuspenseQuery>;
+export type GetRouteQueryResult = Apollo.QueryResult<Types.GetRouteQuery, Types.GetRouteQueryVariables>;
+export const ListShipmentsDocument = gql`
+    query ListShipments($filter: ShipmentFilterInput, $pagination: PaginationInput) {
+  shipments(filter: $filter, pagination: $pagination) {
+    ...ShipmentCore
+  }
+}
+    ${ShipmentCoreFragmentDoc}`;
+
+/**
+ * __useListShipmentsQuery__
+ *
+ * To run a query within a React component, call `useListShipmentsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListShipmentsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useListShipmentsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export function useListShipmentsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListShipmentsQuery, Types.ListShipmentsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.ListShipmentsQuery, Types.ListShipmentsQueryVariables>(ListShipmentsDocument, options);
+      }
+export function useListShipmentsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListShipmentsQuery, Types.ListShipmentsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.ListShipmentsQuery, Types.ListShipmentsQueryVariables>(ListShipmentsDocument, options);
+        }
+// @ts-ignore
+export function useListShipmentsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListShipmentsQuery, Types.ListShipmentsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListShipmentsQuery, Types.ListShipmentsQueryVariables>;
+export function useListShipmentsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListShipmentsQuery, Types.ListShipmentsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListShipmentsQuery | undefined, Types.ListShipmentsQueryVariables>;
+export function useListShipmentsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListShipmentsQuery, Types.ListShipmentsQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.ListShipmentsQuery, Types.ListShipmentsQueryVariables>(ListShipmentsDocument, options);
+        }
+export type ListShipmentsQueryHookResult = ReturnType<typeof useListShipmentsQuery>;
+export type ListShipmentsLazyQueryHookResult = ReturnType<typeof useListShipmentsLazyQuery>;
+export type ListShipmentsSuspenseQueryHookResult = ReturnType<typeof useListShipmentsSuspenseQuery>;
+export type ListShipmentsQueryResult = Apollo.QueryResult<Types.ListShipmentsQuery, Types.ListShipmentsQueryVariables>;
+export const GetShipmentDocument = gql`
+    query GetShipment($id: ID!) {
+  shipment(id: $id) {
+    ...ShipmentCore
+    trackingEvents {
+      id
+      eventType
+      location
+      details
+      timestamp
+    }
+  }
+}
+    ${ShipmentCoreFragmentDoc}`;
+
+/**
+ * __useGetShipmentQuery__
+ *
+ * To run a query within a React component, call `useGetShipmentQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetShipmentQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetShipmentQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetShipmentQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetShipmentQuery, Types.GetShipmentQueryVariables> & ({ variables: Types.GetShipmentQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetShipmentQuery, Types.GetShipmentQueryVariables>(GetShipmentDocument, options);
+      }
+export function useGetShipmentLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetShipmentQuery, Types.GetShipmentQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetShipmentQuery, Types.GetShipmentQueryVariables>(GetShipmentDocument, options);
+        }
+// @ts-ignore
+export function useGetShipmentSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetShipmentQuery, Types.GetShipmentQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetShipmentQuery, Types.GetShipmentQueryVariables>;
+export function useGetShipmentSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetShipmentQuery, Types.GetShipmentQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetShipmentQuery | undefined, Types.GetShipmentQueryVariables>;
+export function useGetShipmentSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetShipmentQuery, Types.GetShipmentQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetShipmentQuery, Types.GetShipmentQueryVariables>(GetShipmentDocument, options);
+        }
+export type GetShipmentQueryHookResult = ReturnType<typeof useGetShipmentQuery>;
+export type GetShipmentLazyQueryHookResult = ReturnType<typeof useGetShipmentLazyQuery>;
+export type GetShipmentSuspenseQueryHookResult = ReturnType<typeof useGetShipmentSuspenseQuery>;
+export type GetShipmentQueryResult = Apollo.QueryResult<Types.GetShipmentQuery, Types.GetShipmentQueryVariables>;
+export const GetOrderTrackingDocument = gql`
+    query GetOrderTracking($orderId: ID!) {
+  orderTracking(orderId: $orderId) {
+    id
+    shipmentId
+    eventType
+    location
+    details
+    timestamp
+  }
+}
+    `;
+
+/**
+ * __useGetOrderTrackingQuery__
+ *
+ * To run a query within a React component, call `useGetOrderTrackingQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetOrderTrackingQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetOrderTrackingQuery({
+ *   variables: {
+ *      orderId: // value for 'orderId'
+ *   },
+ * });
+ */
+export function useGetOrderTrackingQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetOrderTrackingQuery, Types.GetOrderTrackingQueryVariables> & ({ variables: Types.GetOrderTrackingQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetOrderTrackingQuery, Types.GetOrderTrackingQueryVariables>(GetOrderTrackingDocument, options);
+      }
+export function useGetOrderTrackingLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetOrderTrackingQuery, Types.GetOrderTrackingQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetOrderTrackingQuery, Types.GetOrderTrackingQueryVariables>(GetOrderTrackingDocument, options);
+        }
+// @ts-ignore
+export function useGetOrderTrackingSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOrderTrackingQuery, Types.GetOrderTrackingQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOrderTrackingQuery, Types.GetOrderTrackingQueryVariables>;
+export function useGetOrderTrackingSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOrderTrackingQuery, Types.GetOrderTrackingQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOrderTrackingQuery | undefined, Types.GetOrderTrackingQueryVariables>;
+export function useGetOrderTrackingSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOrderTrackingQuery, Types.GetOrderTrackingQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetOrderTrackingQuery, Types.GetOrderTrackingQueryVariables>(GetOrderTrackingDocument, options);
+        }
+export type GetOrderTrackingQueryHookResult = ReturnType<typeof useGetOrderTrackingQuery>;
+export type GetOrderTrackingLazyQueryHookResult = ReturnType<typeof useGetOrderTrackingLazyQuery>;
+export type GetOrderTrackingSuspenseQueryHookResult = ReturnType<typeof useGetOrderTrackingSuspenseQuery>;
+export type GetOrderTrackingQueryResult = Apollo.QueryResult<Types.GetOrderTrackingQuery, Types.GetOrderTrackingQueryVariables>;
+export const GetActiveDeliveriesDocument = gql`
+    query GetActiveDeliveries {
+  activeDeliveries {
+    ...ShipmentCore
+  }
+}
+    ${ShipmentCoreFragmentDoc}`;
+
+/**
+ * __useGetActiveDeliveriesQuery__
+ *
+ * To run a query within a React component, call `useGetActiveDeliveriesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetActiveDeliveriesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetActiveDeliveriesQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useGetActiveDeliveriesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetActiveDeliveriesQuery, Types.GetActiveDeliveriesQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetActiveDeliveriesQuery, Types.GetActiveDeliveriesQueryVariables>(GetActiveDeliveriesDocument, options);
+      }
+export function useGetActiveDeliveriesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetActiveDeliveriesQuery, Types.GetActiveDeliveriesQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetActiveDeliveriesQuery, Types.GetActiveDeliveriesQueryVariables>(GetActiveDeliveriesDocument, options);
+        }
+// @ts-ignore
+export function useGetActiveDeliveriesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetActiveDeliveriesQuery, Types.GetActiveDeliveriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetActiveDeliveriesQuery, Types.GetActiveDeliveriesQueryVariables>;
+export function useGetActiveDeliveriesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetActiveDeliveriesQuery, Types.GetActiveDeliveriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetActiveDeliveriesQuery | undefined, Types.GetActiveDeliveriesQueryVariables>;
+export function useGetActiveDeliveriesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetActiveDeliveriesQuery, Types.GetActiveDeliveriesQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetActiveDeliveriesQuery, Types.GetActiveDeliveriesQueryVariables>(GetActiveDeliveriesDocument, options);
+        }
+export type GetActiveDeliveriesQueryHookResult = ReturnType<typeof useGetActiveDeliveriesQuery>;
+export type GetActiveDeliveriesLazyQueryHookResult = ReturnType<typeof useGetActiveDeliveriesLazyQuery>;
+export type GetActiveDeliveriesSuspenseQueryHookResult = ReturnType<typeof useGetActiveDeliveriesSuspenseQuery>;
+export type GetActiveDeliveriesQueryResult = Apollo.QueryResult<Types.GetActiveDeliveriesQuery, Types.GetActiveDeliveriesQueryVariables>;
+export const GetTrackingAlertsDocument = gql`
+    query GetTrackingAlerts {
+  trackingAlerts {
+    shipmentId
+    shipmentNumber
+    alertType
+    message
+  }
+}
+    `;
+
+/**
+ * __useGetTrackingAlertsQuery__
+ *
+ * To run a query within a React component, call `useGetTrackingAlertsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTrackingAlertsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetTrackingAlertsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useGetTrackingAlertsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetTrackingAlertsQuery, Types.GetTrackingAlertsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetTrackingAlertsQuery, Types.GetTrackingAlertsQueryVariables>(GetTrackingAlertsDocument, options);
+      }
+export function useGetTrackingAlertsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTrackingAlertsQuery, Types.GetTrackingAlertsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetTrackingAlertsQuery, Types.GetTrackingAlertsQueryVariables>(GetTrackingAlertsDocument, options);
+        }
+// @ts-ignore
+export function useGetTrackingAlertsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTrackingAlertsQuery, Types.GetTrackingAlertsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTrackingAlertsQuery, Types.GetTrackingAlertsQueryVariables>;
+export function useGetTrackingAlertsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTrackingAlertsQuery, Types.GetTrackingAlertsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTrackingAlertsQuery | undefined, Types.GetTrackingAlertsQueryVariables>;
+export function useGetTrackingAlertsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTrackingAlertsQuery, Types.GetTrackingAlertsQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetTrackingAlertsQuery, Types.GetTrackingAlertsQueryVariables>(GetTrackingAlertsDocument, options);
+        }
+export type GetTrackingAlertsQueryHookResult = ReturnType<typeof useGetTrackingAlertsQuery>;
+export type GetTrackingAlertsLazyQueryHookResult = ReturnType<typeof useGetTrackingAlertsLazyQuery>;
+export type GetTrackingAlertsSuspenseQueryHookResult = ReturnType<typeof useGetTrackingAlertsSuspenseQuery>;
+export type GetTrackingAlertsQueryResult = Apollo.QueryResult<Types.GetTrackingAlertsQuery, Types.GetTrackingAlertsQueryVariables>;
+export const ListServiceProvidersDocument = gql`
+    query ListServiceProviders($filter: ServiceProviderFilterInput, $pagination: PaginationInput) {
+  serviceProviders(filter: $filter, pagination: $pagination) {
+    ...ServiceProviderCore
+  }
+}
+    ${ServiceProviderCoreFragmentDoc}`;
+
+/**
+ * __useListServiceProvidersQuery__
+ *
+ * To run a query within a React component, call `useListServiceProvidersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListServiceProvidersQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useListServiceProvidersQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export function useListServiceProvidersQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListServiceProvidersQuery, Types.ListServiceProvidersQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.ListServiceProvidersQuery, Types.ListServiceProvidersQueryVariables>(ListServiceProvidersDocument, options);
+      }
+export function useListServiceProvidersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListServiceProvidersQuery, Types.ListServiceProvidersQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.ListServiceProvidersQuery, Types.ListServiceProvidersQueryVariables>(ListServiceProvidersDocument, options);
+        }
+// @ts-ignore
+export function useListServiceProvidersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListServiceProvidersQuery, Types.ListServiceProvidersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListServiceProvidersQuery, Types.ListServiceProvidersQueryVariables>;
+export function useListServiceProvidersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListServiceProvidersQuery, Types.ListServiceProvidersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListServiceProvidersQuery | undefined, Types.ListServiceProvidersQueryVariables>;
+export function useListServiceProvidersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListServiceProvidersQuery, Types.ListServiceProvidersQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.ListServiceProvidersQuery, Types.ListServiceProvidersQueryVariables>(ListServiceProvidersDocument, options);
+        }
+export type ListServiceProvidersQueryHookResult = ReturnType<typeof useListServiceProvidersQuery>;
+export type ListServiceProvidersLazyQueryHookResult = ReturnType<typeof useListServiceProvidersLazyQuery>;
+export type ListServiceProvidersSuspenseQueryHookResult = ReturnType<typeof useListServiceProvidersSuspenseQuery>;
+export type ListServiceProvidersQueryResult = Apollo.QueryResult<Types.ListServiceProvidersQuery, Types.ListServiceProvidersQueryVariables>;
+export const ListServiceOfferingsDocument = gql`
+    query ListServiceOfferings($filter: ServiceOfferingFilterInput, $pagination: PaginationInput) {
+  serviceOfferings(filter: $filter, pagination: $pagination) {
+    ...ServiceOfferingCore
+    provider {
+      id
+      name
+      type
+      rating
+    }
+  }
+}
+    ${ServiceOfferingCoreFragmentDoc}`;
+
+/**
+ * __useListServiceOfferingsQuery__
+ *
+ * To run a query within a React component, call `useListServiceOfferingsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListServiceOfferingsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useListServiceOfferingsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export function useListServiceOfferingsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListServiceOfferingsQuery, Types.ListServiceOfferingsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.ListServiceOfferingsQuery, Types.ListServiceOfferingsQueryVariables>(ListServiceOfferingsDocument, options);
+      }
+export function useListServiceOfferingsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListServiceOfferingsQuery, Types.ListServiceOfferingsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.ListServiceOfferingsQuery, Types.ListServiceOfferingsQueryVariables>(ListServiceOfferingsDocument, options);
+        }
+// @ts-ignore
+export function useListServiceOfferingsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListServiceOfferingsQuery, Types.ListServiceOfferingsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListServiceOfferingsQuery, Types.ListServiceOfferingsQueryVariables>;
+export function useListServiceOfferingsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListServiceOfferingsQuery, Types.ListServiceOfferingsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListServiceOfferingsQuery | undefined, Types.ListServiceOfferingsQueryVariables>;
+export function useListServiceOfferingsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListServiceOfferingsQuery, Types.ListServiceOfferingsQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.ListServiceOfferingsQuery, Types.ListServiceOfferingsQueryVariables>(ListServiceOfferingsDocument, options);
+        }
+export type ListServiceOfferingsQueryHookResult = ReturnType<typeof useListServiceOfferingsQuery>;
+export type ListServiceOfferingsLazyQueryHookResult = ReturnType<typeof useListServiceOfferingsLazyQuery>;
+export type ListServiceOfferingsSuspenseQueryHookResult = ReturnType<typeof useListServiceOfferingsSuspenseQuery>;
+export type ListServiceOfferingsQueryResult = Apollo.QueryResult<Types.ListServiceOfferingsQuery, Types.ListServiceOfferingsQueryVariables>;
+export const ListMovethewheelsReportsDocument = gql`
+    query ListMovethewheelsReports($filter: MovethewheelsReportFilterInput, $pagination: PaginationInput) {
+  movethewheelsReports(filter: $filter, pagination: $pagination) {
+    ...MovethewheelsReportCore
+  }
+}
+    ${MovethewheelsReportCoreFragmentDoc}`;
+
+/**
+ * __useListMovethewheelsReportsQuery__
+ *
+ * To run a query within a React component, call `useListMovethewheelsReportsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListMovethewheelsReportsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useListMovethewheelsReportsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export function useListMovethewheelsReportsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListMovethewheelsReportsQuery, Types.ListMovethewheelsReportsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.ListMovethewheelsReportsQuery, Types.ListMovethewheelsReportsQueryVariables>(ListMovethewheelsReportsDocument, options);
+      }
+export function useListMovethewheelsReportsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListMovethewheelsReportsQuery, Types.ListMovethewheelsReportsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.ListMovethewheelsReportsQuery, Types.ListMovethewheelsReportsQueryVariables>(ListMovethewheelsReportsDocument, options);
+        }
+// @ts-ignore
+export function useListMovethewheelsReportsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListMovethewheelsReportsQuery, Types.ListMovethewheelsReportsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListMovethewheelsReportsQuery, Types.ListMovethewheelsReportsQueryVariables>;
+export function useListMovethewheelsReportsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListMovethewheelsReportsQuery, Types.ListMovethewheelsReportsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListMovethewheelsReportsQuery | undefined, Types.ListMovethewheelsReportsQueryVariables>;
+export function useListMovethewheelsReportsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListMovethewheelsReportsQuery, Types.ListMovethewheelsReportsQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.ListMovethewheelsReportsQuery, Types.ListMovethewheelsReportsQueryVariables>(ListMovethewheelsReportsDocument, options);
+        }
+export type ListMovethewheelsReportsQueryHookResult = ReturnType<typeof useListMovethewheelsReportsQuery>;
+export type ListMovethewheelsReportsLazyQueryHookResult = ReturnType<typeof useListMovethewheelsReportsLazyQuery>;
+export type ListMovethewheelsReportsSuspenseQueryHookResult = ReturnType<typeof useListMovethewheelsReportsSuspenseQuery>;
+export type ListMovethewheelsReportsQueryResult = Apollo.QueryResult<Types.ListMovethewheelsReportsQuery, Types.ListMovethewheelsReportsQueryVariables>;
+export const GetMovethewheelsReportDocument = gql`
+    query GetMovethewheelsReport($id: ID!) {
+  movethewheelsReport(id: $id) {
+    ...MovethewheelsReportCore
+  }
+}
+    ${MovethewheelsReportCoreFragmentDoc}`;
+
+/**
+ * __useGetMovethewheelsReportQuery__
+ *
+ * To run a query within a React component, call `useGetMovethewheelsReportQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMovethewheelsReportQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetMovethewheelsReportQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetMovethewheelsReportQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetMovethewheelsReportQuery, Types.GetMovethewheelsReportQueryVariables> & ({ variables: Types.GetMovethewheelsReportQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetMovethewheelsReportQuery, Types.GetMovethewheelsReportQueryVariables>(GetMovethewheelsReportDocument, options);
+      }
+export function useGetMovethewheelsReportLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMovethewheelsReportQuery, Types.GetMovethewheelsReportQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetMovethewheelsReportQuery, Types.GetMovethewheelsReportQueryVariables>(GetMovethewheelsReportDocument, options);
+        }
+// @ts-ignore
+export function useGetMovethewheelsReportSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMovethewheelsReportQuery, Types.GetMovethewheelsReportQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMovethewheelsReportQuery, Types.GetMovethewheelsReportQueryVariables>;
+export function useGetMovethewheelsReportSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMovethewheelsReportQuery, Types.GetMovethewheelsReportQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMovethewheelsReportQuery | undefined, Types.GetMovethewheelsReportQueryVariables>;
+export function useGetMovethewheelsReportSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMovethewheelsReportQuery, Types.GetMovethewheelsReportQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetMovethewheelsReportQuery, Types.GetMovethewheelsReportQueryVariables>(GetMovethewheelsReportDocument, options);
+        }
+export type GetMovethewheelsReportQueryHookResult = ReturnType<typeof useGetMovethewheelsReportQuery>;
+export type GetMovethewheelsReportLazyQueryHookResult = ReturnType<typeof useGetMovethewheelsReportLazyQuery>;
+export type GetMovethewheelsReportSuspenseQueryHookResult = ReturnType<typeof useGetMovethewheelsReportSuspenseQuery>;
+export type GetMovethewheelsReportQueryResult = Apollo.QueryResult<Types.GetMovethewheelsReportQuery, Types.GetMovethewheelsReportQueryVariables>;
+export const GetMovethewheelsModuleSettingsDocument = gql`
+    query GetMovethewheelsModuleSettings {
+  moduleSettings {
+    workspaceId
+    preferences
+    updatedAt
+  }
+}
+    `;
+
+/**
+ * __useGetMovethewheelsModuleSettingsQuery__
+ *
+ * To run a query within a React component, call `useGetMovethewheelsModuleSettingsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMovethewheelsModuleSettingsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetMovethewheelsModuleSettingsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useGetMovethewheelsModuleSettingsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetMovethewheelsModuleSettingsQuery, Types.GetMovethewheelsModuleSettingsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetMovethewheelsModuleSettingsQuery, Types.GetMovethewheelsModuleSettingsQueryVariables>(GetMovethewheelsModuleSettingsDocument, options);
+      }
+export function useGetMovethewheelsModuleSettingsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMovethewheelsModuleSettingsQuery, Types.GetMovethewheelsModuleSettingsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetMovethewheelsModuleSettingsQuery, Types.GetMovethewheelsModuleSettingsQueryVariables>(GetMovethewheelsModuleSettingsDocument, options);
+        }
+// @ts-ignore
+export function useGetMovethewheelsModuleSettingsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMovethewheelsModuleSettingsQuery, Types.GetMovethewheelsModuleSettingsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMovethewheelsModuleSettingsQuery, Types.GetMovethewheelsModuleSettingsQueryVariables>;
+export function useGetMovethewheelsModuleSettingsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMovethewheelsModuleSettingsQuery, Types.GetMovethewheelsModuleSettingsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMovethewheelsModuleSettingsQuery | undefined, Types.GetMovethewheelsModuleSettingsQueryVariables>;
+export function useGetMovethewheelsModuleSettingsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMovethewheelsModuleSettingsQuery, Types.GetMovethewheelsModuleSettingsQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetMovethewheelsModuleSettingsQuery, Types.GetMovethewheelsModuleSettingsQueryVariables>(GetMovethewheelsModuleSettingsDocument, options);
+        }
+export type GetMovethewheelsModuleSettingsQueryHookResult = ReturnType<typeof useGetMovethewheelsModuleSettingsQuery>;
+export type GetMovethewheelsModuleSettingsLazyQueryHookResult = ReturnType<typeof useGetMovethewheelsModuleSettingsLazyQuery>;
+export type GetMovethewheelsModuleSettingsSuspenseQueryHookResult = ReturnType<typeof useGetMovethewheelsModuleSettingsSuspenseQuery>;
+export type GetMovethewheelsModuleSettingsQueryResult = Apollo.QueryResult<Types.GetMovethewheelsModuleSettingsQuery, Types.GetMovethewheelsModuleSettingsQueryVariables>;
+export const ListMovethewheelsOrdersDocument = gql`
+    query ListMovethewheelsOrders($filter: OrderFilterInput, $pagination: PaginationInput) {
+  movethewheelsOrders(filter: $filter, pagination: $pagination) {
+    ...MovethewheelsOrderCore
+  }
+}
+    ${MovethewheelsOrderCoreFragmentDoc}`;
+
+/**
+ * __useListMovethewheelsOrdersQuery__
+ *
+ * To run a query within a React component, call `useListMovethewheelsOrdersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListMovethewheelsOrdersQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useListMovethewheelsOrdersQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export function useListMovethewheelsOrdersQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListMovethewheelsOrdersQuery, Types.ListMovethewheelsOrdersQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.ListMovethewheelsOrdersQuery, Types.ListMovethewheelsOrdersQueryVariables>(ListMovethewheelsOrdersDocument, options);
+      }
+export function useListMovethewheelsOrdersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListMovethewheelsOrdersQuery, Types.ListMovethewheelsOrdersQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.ListMovethewheelsOrdersQuery, Types.ListMovethewheelsOrdersQueryVariables>(ListMovethewheelsOrdersDocument, options);
+        }
+// @ts-ignore
+export function useListMovethewheelsOrdersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListMovethewheelsOrdersQuery, Types.ListMovethewheelsOrdersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListMovethewheelsOrdersQuery, Types.ListMovethewheelsOrdersQueryVariables>;
+export function useListMovethewheelsOrdersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListMovethewheelsOrdersQuery, Types.ListMovethewheelsOrdersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListMovethewheelsOrdersQuery | undefined, Types.ListMovethewheelsOrdersQueryVariables>;
+export function useListMovethewheelsOrdersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListMovethewheelsOrdersQuery, Types.ListMovethewheelsOrdersQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.ListMovethewheelsOrdersQuery, Types.ListMovethewheelsOrdersQueryVariables>(ListMovethewheelsOrdersDocument, options);
+        }
+export type ListMovethewheelsOrdersQueryHookResult = ReturnType<typeof useListMovethewheelsOrdersQuery>;
+export type ListMovethewheelsOrdersLazyQueryHookResult = ReturnType<typeof useListMovethewheelsOrdersLazyQuery>;
+export type ListMovethewheelsOrdersSuspenseQueryHookResult = ReturnType<typeof useListMovethewheelsOrdersSuspenseQuery>;
+export type ListMovethewheelsOrdersQueryResult = Apollo.QueryResult<Types.ListMovethewheelsOrdersQuery, Types.ListMovethewheelsOrdersQueryVariables>;
+export const GetMovethewheelsOrderDocument = gql`
+    query GetMovethewheelsOrder($id: ID!) {
+  movethewheelsOrder(id: $id) {
+    ...MovethewheelsOrderCore
+    customer {
+      id
+      name
+      email
+      phone
+    }
+    vehicle {
+      id
+      vehicleNumber
+      type
+      status
+    }
+    driver {
+      id
+      firstName
+      lastName
+      status
+    }
+    statusHistory {
+      id
+      status
+      previousStatus
+      notes
+      location
+      createdAt
+    }
+    shipment {
+      id
+      shipmentNumber
+      status
+      trackingNumber
+    }
+  }
+}
+    ${MovethewheelsOrderCoreFragmentDoc}`;
+
+/**
+ * __useGetMovethewheelsOrderQuery__
+ *
+ * To run a query within a React component, call `useGetMovethewheelsOrderQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMovethewheelsOrderQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetMovethewheelsOrderQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export function useGetMovethewheelsOrderQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetMovethewheelsOrderQuery, Types.GetMovethewheelsOrderQueryVariables> & ({ variables: Types.GetMovethewheelsOrderQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
+        const options = {...defaultOptions, ...baseOptions}
+        return ApolloReactHooks.useQuery<Types.GetMovethewheelsOrderQuery, Types.GetMovethewheelsOrderQueryVariables>(GetMovethewheelsOrderDocument, options);
+      }
+export function useGetMovethewheelsOrderLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMovethewheelsOrderQuery, Types.GetMovethewheelsOrderQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useLazyQuery<Types.GetMovethewheelsOrderQuery, Types.GetMovethewheelsOrderQueryVariables>(GetMovethewheelsOrderDocument, options);
+        }
+// @ts-ignore
+export function useGetMovethewheelsOrderSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMovethewheelsOrderQuery, Types.GetMovethewheelsOrderQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMovethewheelsOrderQuery, Types.GetMovethewheelsOrderQueryVariables>;
+export function useGetMovethewheelsOrderSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMovethewheelsOrderQuery, Types.GetMovethewheelsOrderQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMovethewheelsOrderQuery | undefined, Types.GetMovethewheelsOrderQueryVariables>;
+export function useGetMovethewheelsOrderSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMovethewheelsOrderQuery, Types.GetMovethewheelsOrderQueryVariables>) {
+          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
+          return ApolloReactHooks.useSuspenseQuery<Types.GetMovethewheelsOrderQuery, Types.GetMovethewheelsOrderQueryVariables>(GetMovethewheelsOrderDocument, options);
+        }
+export type GetMovethewheelsOrderQueryHookResult = ReturnType<typeof useGetMovethewheelsOrderQuery>;
+export type GetMovethewheelsOrderLazyQueryHookResult = ReturnType<typeof useGetMovethewheelsOrderLazyQuery>;
+export type GetMovethewheelsOrderSuspenseQueryHookResult = ReturnType<typeof useGetMovethewheelsOrderSuspenseQuery>;
+export type GetMovethewheelsOrderQueryResult = Apollo.QueryResult<Types.GetMovethewheelsOrderQuery, Types.GetMovethewheelsOrderQueryVariables>;