@burdenoff/microfe-movethewheels 2026.930.4 → 2026.1010.1

package/dist/generated/trip-utilization-operations.d.ts

@@ -0,0 +1,651 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    DateTime: {
+        input: string;
+        output: string;
+    };
+};
+/** Bounded audit snapshot of at most 10 exact evidence versions. */
+export type MtwContainerEvidence = {
+    __typename?: 'MtwContainerEvidence';
+    checkedAt: Scalars['DateTime']['output'];
+    fileId: Scalars['ID']['output'];
+    sha256Hash: Scalars['String']['output'];
+    versionId: Scalars['ID']['output'];
+};
+/** Exact shared Files version. The fingerprint establishes integrity, not issuer authenticity. */
+export type MtwContainerEvidenceInput = {
+    fileId: Scalars['ID']['input'];
+    versionId: Scalars['ID']['input'];
+};
+export type MtwContainerPagination = {
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+};
+export type MtwRoute = {
+    __typename?: 'MtwRoute';
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    status: RouteStatus;
+    updatedAt: Scalars['DateTime']['output'];
+    vehicle?: Maybe<MtwVehicle>;
+    vehicleId?: Maybe<Scalars['ID']['output']>;
+};
+export type MtwTripUtilizationBasis = 'ESTIMATED' | 'OBSERVED';
+export type MtwTripUtilizationCoverage = 'COMPLETE' | 'PARTIAL';
+/** Immutable historical operator report of a captured route/vehicle revision; no assignment or dispatch change. */
+export type MtwTripUtilizationReport = {
+    __typename?: 'MtwTripUtilizationReport';
+    actorProvenance: Scalars['String']['output'];
+    basis: MtwTripUtilizationBasis;
+    createdBy: Scalars['ID']['output'];
+    declaredCoverage: MtwTripUtilizationCoverage;
+    evidence: Array<MtwContainerEvidence>;
+    id: Scalars['ID']['output'];
+    intervalFrom: Scalars['DateTime']['output'];
+    intervalUntil: Scalars['DateTime']['output'];
+    recordedAt: Scalars['DateTime']['output'];
+    routeId: Scalars['ID']['output'];
+    routeUpdatedAt: Scalars['DateTime']['output'];
+    routeWaypointsFingerprint: Scalars['String']['output'];
+    schemaVersion: Scalars['Int']['output'];
+    summary: MtwTripUtilizationSummary;
+    tripId: Scalars['ID']['output'];
+    vehicleId: Scalars['ID']['output'];
+    vehicleUpdatedAt: Scalars['DateTime']['output'];
+};
+export type MtwTripUtilizationReportPage = {
+    __typename?: 'MtwTripUtilizationReportPage';
+    hasMore: Scalars['Boolean']['output'];
+    items: Array<MtwTripUtilizationReport>;
+    limit: Scalars['Int']['output'];
+    nextOffset?: Maybe<Scalars['Int']['output']>;
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type MtwTripUtilizationSegment = {
+    __typename?: 'MtwTripUtilizationSegment';
+    basis: MtwTripUtilizationBasis;
+    cubeCapacityM3?: Maybe<Scalars['Float']['output']>;
+    cubeM3?: Maybe<Scalars['Float']['output']>;
+    cubeUtilizationPercentage?: Maybe<Scalars['Float']['output']>;
+    distanceKm?: Maybe<Scalars['Float']['output']>;
+    loadedState: MtwUtilizationLoadedState;
+    payloadCapacityKg?: Maybe<Scalars['Float']['output']>;
+    payloadKg?: Maybe<Scalars['Float']['output']>;
+    segmentId: Scalars['ID']['output'];
+    sequence: Scalars['Int']['output'];
+    source: MtwUtilizationSource;
+    warnings: Array<MtwUtilizationWarning>;
+    weightUtilizationPercentage?: Maybe<Scalars['Float']['output']>;
+};
+export type MtwTripUtilizationSegmentInput = {
+    cubeCapacityM3?: InputMaybe<Scalars['Float']['input']>;
+    cubeM3?: InputMaybe<Scalars['Float']['input']>;
+    distanceKm?: InputMaybe<Scalars['Float']['input']>;
+    loadedState: MtwUtilizationLoadedState;
+    payloadCapacityKg?: InputMaybe<Scalars['Float']['input']>;
+    payloadKg?: InputMaybe<Scalars['Float']['input']>;
+    segmentId: Scalars['ID']['input'];
+    sequence: Scalars['Int']['input'];
+    source: MtwUtilizationSourceInput;
+};
+/** COMPLETE is operator-declared coverage; these ratios are not feasibility, road, axle or fuel certificates. */
+export type MtwTripUtilizationSummary = {
+    __typename?: 'MtwTripUtilizationSummary';
+    basis: MtwTripUtilizationBasis;
+    declaredCoverage: MtwTripUtilizationCoverage;
+    distanceCoverage: MtwUtilizationDistanceCoverage;
+    distanceWeightedCube: MtwUtilizationMetric;
+    distanceWeightedWeight: MtwUtilizationMetric;
+    loadedDistance: MtwUtilizationMetric;
+    segmentCount: Scalars['Int']['output'];
+    segments: Array<MtwTripUtilizationSegment>;
+    tripId: Scalars['ID']['output'];
+    unknownFactsSegmentCount: Scalars['Int']['output'];
+};
+export type MtwUtilizationCapacityBasis = 'MEASURED' | 'RATED';
+export type MtwUtilizationDistanceBasis = 'MEASURED' | 'OPERATOR_ESTIMATE' | 'PROVIDER_ESTIMATE';
+export type MtwUtilizationDistanceCoverage = {
+    __typename?: 'MtwUtilizationDistanceCoverage';
+    knownDistanceKm: Scalars['Float']['output'];
+    knownSegmentCount: Scalars['Int']['output'];
+    totalDistanceKm?: Maybe<Scalars['Float']['output']>;
+    unknownSegmentCount: Scalars['Int']['output'];
+};
+export type MtwUtilizationLoadBasis = 'MEASURED' | 'SOURCE_CONFIRMED_PLAN';
+export type MtwUtilizationLoadedState = 'EMPTY' | 'LOADED' | 'UNKNOWN';
+export type MtwUtilizationMetric = {
+    __typename?: 'MtwUtilizationMetric';
+    knownDistanceKm: Scalars['Float']['output'];
+    percentage?: Maybe<Scalars['Float']['output']>;
+    reason?: Maybe<MtwUtilizationMetricReason>;
+    status: MtwUtilizationMetricStatus;
+    unknownSegmentCount: Scalars['Int']['output'];
+};
+export type MtwUtilizationMetricReason = 'DISTANCE_UNKNOWN' | 'NO_SEGMENTS' | 'PARTIAL_TRIP' | 'SEGMENT_FACTS_UNKNOWN' | 'ZERO_DISTANCE';
+export type MtwUtilizationMetricStatus = 'KNOWN' | 'UNKNOWN';
+/** Human-recorded source labels, not independent measurement or provider authentication. */
+export type MtwUtilizationSource = {
+    __typename?: 'MtwUtilizationSource';
+    capacityBasis: MtwUtilizationCapacityBasis;
+    distanceBasis: MtwUtilizationDistanceBasis;
+    loadBasis: MtwUtilizationLoadBasis;
+    observedAt?: Maybe<Scalars['DateTime']['output']>;
+    recordedAt: Scalars['DateTime']['output'];
+    reference: Scalars['String']['output'];
+    revision: Scalars['String']['output'];
+};
+export type MtwUtilizationSourceInput = {
+    capacityBasis: MtwUtilizationCapacityBasis;
+    distanceBasis: MtwUtilizationDistanceBasis;
+    loadBasis: MtwUtilizationLoadBasis;
+    observedAt?: InputMaybe<Scalars['DateTime']['input']>;
+    reference: Scalars['String']['input'];
+    revision: Scalars['String']['input'];
+};
+export type MtwUtilizationWarning = 'CUBE_OVERLOAD' | 'EMPTY_WITH_PAYLOAD' | 'WEIGHT_OVERLOAD';
+export type MtwVehicle = {
+    __typename?: 'MtwVehicle';
+    id: Scalars['ID']['output'];
+    licensePlate?: Maybe<Scalars['String']['output']>;
+    status: VehicleStatus;
+    type: VehicleType;
+    updatedAt: Scalars['DateTime']['output'];
+    vehicleNumber: Scalars['String']['output'];
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    recordMtwTripUtilizationReport: MtwTripUtilizationReport;
+};
+export type MutationRecordMtwTripUtilizationReportArgs = {
+    input: RecordMtwTripUtilizationReportInput;
+};
+export type PaginationInput = {
+    cursor?: InputMaybe<Scalars['String']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+};
+export type Query = {
+    __typename?: 'Query';
+    mtwTripUtilizationReportPage: MtwTripUtilizationReportPage;
+    route?: Maybe<MtwRoute>;
+    routes: Array<MtwRoute>;
+    routesCount: Scalars['Int']['output'];
+    vehicle?: Maybe<MtwVehicle>;
+};
+export type QueryMtwTripUtilizationReportPageArgs = {
+    pagination?: InputMaybe<MtwContainerPagination>;
+    routeId: Scalars['ID']['input'];
+};
+export type QueryRouteArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryRoutesArgs = {
+    filter?: InputMaybe<RouteFilterInput>;
+    pagination?: InputMaybe<PaginationInput>;
+};
+export type QueryRoutesCountArgs = {
+    filter?: InputMaybe<RouteFilterInput>;
+};
+export type QueryVehicleArgs = {
+    id: Scalars['ID']['input'];
+};
+export type RecordMtwTripUtilizationReportInput = {
+    basis: MtwTripUtilizationBasis;
+    declaredCoverage: MtwTripUtilizationCoverage;
+    evidence: Array<MtwContainerEvidenceInput>;
+    expectedRouteUpdatedAt: Scalars['DateTime']['input'];
+    expectedVehicleUpdatedAt: Scalars['DateTime']['input'];
+    idempotencyKey: Scalars['String']['input'];
+    intervalFrom: Scalars['DateTime']['input'];
+    intervalUntil: Scalars['DateTime']['input'];
+    routeId: Scalars['ID']['input'];
+    segments: Array<MtwTripUtilizationSegmentInput>;
+    tripId: Scalars['ID']['input'];
+    vehicleId: Scalars['ID']['input'];
+};
+export type RouteFilterInput = {
+    driverId?: InputMaybe<Scalars['ID']['input']>;
+    search?: InputMaybe<Scalars['String']['input']>;
+    shipmentId?: InputMaybe<Scalars['ID']['input']>;
+    status?: InputMaybe<RouteStatus>;
+    vehicleId?: InputMaybe<Scalars['ID']['input']>;
+};
+export type RouteStatus = 'CANCELLED' | 'COMPLETED' | 'IN_PROGRESS' | 'PLANNED';
+export type VehicleStatus = 'ACTIVE' | 'DECOMMISSIONED' | 'INACTIVE' | 'IN_TRANSIT' | 'MAINTENANCE';
+export type VehicleType = 'BICYCLE' | 'DRONE' | 'FLATBED' | 'MOTORCYCLE' | 'REFRIGERATED' | 'SEMI_TRAILER' | 'TRUCK' | 'VAN';
+export type UtilizationVehicleFragment = {
+    __typename?: 'MtwVehicle';
+    id: string;
+    vehicleNumber: string;
+    licensePlate?: string | null;
+    type: VehicleType;
+    status: VehicleStatus;
+    updatedAt: string;
+};
+export type UtilizationRouteFragment = {
+    __typename?: 'MtwRoute';
+    id: string;
+    name: string;
+    status: RouteStatus;
+    updatedAt: string;
+    vehicleId?: string | null;
+    vehicle?: {
+        __typename?: 'MtwVehicle';
+        id: string;
+        vehicleNumber: string;
+        licensePlate?: string | null;
+        type: VehicleType;
+        status: VehicleStatus;
+        updatedAt: string;
+    } | null;
+};
+export type UtilizationRoutesQueryVariables = Exact<{
+    pagination: PaginationInput;
+}>;
+export type UtilizationRoutesQuery = {
+    __typename?: 'Query';
+    routesCount: number;
+    routes: Array<{
+        __typename?: 'MtwRoute';
+        id: string;
+        name: string;
+        status: RouteStatus;
+        updatedAt: string;
+        vehicleId?: string | null;
+        vehicle?: {
+            __typename?: 'MtwVehicle';
+            id: string;
+            vehicleNumber: string;
+            licensePlate?: string | null;
+            type: VehicleType;
+            status: VehicleStatus;
+            updatedAt: string;
+        } | null;
+    }>;
+};
+export type UtilizationCurrentRouteQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type UtilizationCurrentRouteQuery = {
+    __typename?: 'Query';
+    route?: {
+        __typename?: 'MtwRoute';
+        id: string;
+        name: string;
+        status: RouteStatus;
+        updatedAt: string;
+        vehicleId?: string | null;
+        vehicle?: {
+            __typename?: 'MtwVehicle';
+            id: string;
+            vehicleNumber: string;
+            licensePlate?: string | null;
+            type: VehicleType;
+            status: VehicleStatus;
+            updatedAt: string;
+        } | null;
+    } | null;
+};
+export type UtilizationCurrentVehicleQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type UtilizationCurrentVehicleQuery = {
+    __typename?: 'Query';
+    vehicle?: {
+        __typename?: 'MtwVehicle';
+        id: string;
+        vehicleNumber: string;
+        licensePlate?: string | null;
+        type: VehicleType;
+        status: VehicleStatus;
+        updatedAt: string;
+    } | null;
+};
+export type UtilizationMetricFragment = {
+    __typename?: 'MtwUtilizationMetric';
+    status: MtwUtilizationMetricStatus;
+    percentage?: number | null;
+    knownDistanceKm: number;
+    unknownSegmentCount: number;
+    reason?: MtwUtilizationMetricReason | null;
+};
+export type UtilizationReportFragment = {
+    __typename?: 'MtwTripUtilizationReport';
+    id: string;
+    routeId: string;
+    vehicleId: string;
+    routeUpdatedAt: string;
+    vehicleUpdatedAt: string;
+    routeWaypointsFingerprint: string;
+    tripId: string;
+    basis: MtwTripUtilizationBasis;
+    declaredCoverage: MtwTripUtilizationCoverage;
+    intervalFrom: string;
+    intervalUntil: string;
+    schemaVersion: number;
+    recordedAt: string;
+    createdBy: string;
+    actorProvenance: string;
+    evidence: Array<{
+        __typename?: 'MtwContainerEvidence';
+        fileId: string;
+        versionId: string;
+        sha256Hash: string;
+        checkedAt: string;
+    }>;
+    summary: {
+        __typename?: 'MtwTripUtilizationSummary';
+        tripId: string;
+        basis: MtwTripUtilizationBasis;
+        declaredCoverage: MtwTripUtilizationCoverage;
+        segmentCount: number;
+        unknownFactsSegmentCount: number;
+        distanceCoverage: {
+            __typename?: 'MtwUtilizationDistanceCoverage';
+            knownSegmentCount: number;
+            unknownSegmentCount: number;
+            knownDistanceKm: number;
+            totalDistanceKm?: number | null;
+        };
+        loadedDistance: {
+            __typename?: 'MtwUtilizationMetric';
+            status: MtwUtilizationMetricStatus;
+            percentage?: number | null;
+            knownDistanceKm: number;
+            unknownSegmentCount: number;
+            reason?: MtwUtilizationMetricReason | null;
+        };
+        distanceWeightedWeight: {
+            __typename?: 'MtwUtilizationMetric';
+            status: MtwUtilizationMetricStatus;
+            percentage?: number | null;
+            knownDistanceKm: number;
+            unknownSegmentCount: number;
+            reason?: MtwUtilizationMetricReason | null;
+        };
+        distanceWeightedCube: {
+            __typename?: 'MtwUtilizationMetric';
+            status: MtwUtilizationMetricStatus;
+            percentage?: number | null;
+            knownDistanceKm: number;
+            unknownSegmentCount: number;
+            reason?: MtwUtilizationMetricReason | null;
+        };
+        segments: Array<{
+            __typename?: 'MtwTripUtilizationSegment';
+            segmentId: string;
+            sequence: number;
+            basis: MtwTripUtilizationBasis;
+            loadedState: MtwUtilizationLoadedState;
+            distanceKm?: number | null;
+            payloadKg?: number | null;
+            payloadCapacityKg?: number | null;
+            cubeM3?: number | null;
+            cubeCapacityM3?: number | null;
+            weightUtilizationPercentage?: number | null;
+            cubeUtilizationPercentage?: number | null;
+            warnings: Array<MtwUtilizationWarning>;
+            source: {
+                __typename?: 'MtwUtilizationSource';
+                reference: string;
+                revision: string;
+                recordedAt: string;
+                observedAt?: string | null;
+                distanceBasis: MtwUtilizationDistanceBasis;
+                loadBasis: MtwUtilizationLoadBasis;
+                capacityBasis: MtwUtilizationCapacityBasis;
+            };
+        }>;
+    };
+};
+export type UtilizationReportsQueryVariables = Exact<{
+    routeId: Scalars['ID']['input'];
+    pagination: MtwContainerPagination;
+}>;
+export type UtilizationReportsQuery = {
+    __typename?: 'Query';
+    mtwTripUtilizationReportPage: {
+        __typename?: 'MtwTripUtilizationReportPage';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextOffset?: number | null;
+        items: Array<{
+            __typename?: 'MtwTripUtilizationReport';
+            id: string;
+            routeId: string;
+            vehicleId: string;
+            routeUpdatedAt: string;
+            vehicleUpdatedAt: string;
+            routeWaypointsFingerprint: string;
+            tripId: string;
+            basis: MtwTripUtilizationBasis;
+            declaredCoverage: MtwTripUtilizationCoverage;
+            intervalFrom: string;
+            intervalUntil: string;
+            schemaVersion: number;
+            recordedAt: string;
+            createdBy: string;
+            actorProvenance: string;
+            evidence: Array<{
+                __typename?: 'MtwContainerEvidence';
+                fileId: string;
+                versionId: string;
+                sha256Hash: string;
+                checkedAt: string;
+            }>;
+            summary: {
+                __typename?: 'MtwTripUtilizationSummary';
+                tripId: string;
+                basis: MtwTripUtilizationBasis;
+                declaredCoverage: MtwTripUtilizationCoverage;
+                segmentCount: number;
+                unknownFactsSegmentCount: number;
+                distanceCoverage: {
+                    __typename?: 'MtwUtilizationDistanceCoverage';
+                    knownSegmentCount: number;
+                    unknownSegmentCount: number;
+                    knownDistanceKm: number;
+                    totalDistanceKm?: number | null;
+                };
+                loadedDistance: {
+                    __typename?: 'MtwUtilizationMetric';
+                    status: MtwUtilizationMetricStatus;
+                    percentage?: number | null;
+                    knownDistanceKm: number;
+                    unknownSegmentCount: number;
+                    reason?: MtwUtilizationMetricReason | null;
+                };
+                distanceWeightedWeight: {
+                    __typename?: 'MtwUtilizationMetric';
+                    status: MtwUtilizationMetricStatus;
+                    percentage?: number | null;
+                    knownDistanceKm: number;
+                    unknownSegmentCount: number;
+                    reason?: MtwUtilizationMetricReason | null;
+                };
+                distanceWeightedCube: {
+                    __typename?: 'MtwUtilizationMetric';
+                    status: MtwUtilizationMetricStatus;
+                    percentage?: number | null;
+                    knownDistanceKm: number;
+                    unknownSegmentCount: number;
+                    reason?: MtwUtilizationMetricReason | null;
+                };
+                segments: Array<{
+                    __typename?: 'MtwTripUtilizationSegment';
+                    segmentId: string;
+                    sequence: number;
+                    basis: MtwTripUtilizationBasis;
+                    loadedState: MtwUtilizationLoadedState;
+                    distanceKm?: number | null;
+                    payloadKg?: number | null;
+                    payloadCapacityKg?: number | null;
+                    cubeM3?: number | null;
+                    cubeCapacityM3?: number | null;
+                    weightUtilizationPercentage?: number | null;
+                    cubeUtilizationPercentage?: number | null;
+                    warnings: Array<MtwUtilizationWarning>;
+                    source: {
+                        __typename?: 'MtwUtilizationSource';
+                        reference: string;
+                        revision: string;
+                        recordedAt: string;
+                        observedAt?: string | null;
+                        distanceBasis: MtwUtilizationDistanceBasis;
+                        loadBasis: MtwUtilizationLoadBasis;
+                        capacityBasis: MtwUtilizationCapacityBasis;
+                    };
+                }>;
+            };
+        }>;
+    };
+};
+export type RecordUtilizationReportMutationVariables = Exact<{
+    input: RecordMtwTripUtilizationReportInput;
+}>;
+export type RecordUtilizationReportMutation = {
+    __typename?: 'Mutation';
+    recordMtwTripUtilizationReport: {
+        __typename?: 'MtwTripUtilizationReport';
+        id: string;
+        routeId: string;
+        vehicleId: string;
+        routeUpdatedAt: string;
+        vehicleUpdatedAt: string;
+        routeWaypointsFingerprint: string;
+        tripId: string;
+        basis: MtwTripUtilizationBasis;
+        declaredCoverage: MtwTripUtilizationCoverage;
+        intervalFrom: string;
+        intervalUntil: string;
+        schemaVersion: number;
+        recordedAt: string;
+        createdBy: string;
+        actorProvenance: string;
+        evidence: Array<{
+            __typename?: 'MtwContainerEvidence';
+            fileId: string;
+            versionId: string;
+            sha256Hash: string;
+            checkedAt: string;
+        }>;
+        summary: {
+            __typename?: 'MtwTripUtilizationSummary';
+            tripId: string;
+            basis: MtwTripUtilizationBasis;
+            declaredCoverage: MtwTripUtilizationCoverage;
+            segmentCount: number;
+            unknownFactsSegmentCount: number;
+            distanceCoverage: {
+                __typename?: 'MtwUtilizationDistanceCoverage';
+                knownSegmentCount: number;
+                unknownSegmentCount: number;
+                knownDistanceKm: number;
+                totalDistanceKm?: number | null;
+            };
+            loadedDistance: {
+                __typename?: 'MtwUtilizationMetric';
+                status: MtwUtilizationMetricStatus;
+                percentage?: number | null;
+                knownDistanceKm: number;
+                unknownSegmentCount: number;
+                reason?: MtwUtilizationMetricReason | null;
+            };
+            distanceWeightedWeight: {
+                __typename?: 'MtwUtilizationMetric';
+                status: MtwUtilizationMetricStatus;
+                percentage?: number | null;
+                knownDistanceKm: number;
+                unknownSegmentCount: number;
+                reason?: MtwUtilizationMetricReason | null;
+            };
+            distanceWeightedCube: {
+                __typename?: 'MtwUtilizationMetric';
+                status: MtwUtilizationMetricStatus;
+                percentage?: number | null;
+                knownDistanceKm: number;
+                unknownSegmentCount: number;
+                reason?: MtwUtilizationMetricReason | null;
+            };
+            segments: Array<{
+                __typename?: 'MtwTripUtilizationSegment';
+                segmentId: string;
+                sequence: number;
+                basis: MtwTripUtilizationBasis;
+                loadedState: MtwUtilizationLoadedState;
+                distanceKm?: number | null;
+                payloadKg?: number | null;
+                payloadCapacityKg?: number | null;
+                cubeM3?: number | null;
+                cubeCapacityM3?: number | null;
+                weightUtilizationPercentage?: number | null;
+                cubeUtilizationPercentage?: number | null;
+                warnings: Array<MtwUtilizationWarning>;
+                source: {
+                    __typename?: 'MtwUtilizationSource';
+                    reference: string;
+                    revision: string;
+                    recordedAt: string;
+                    observedAt?: string | null;
+                    distanceBasis: MtwUtilizationDistanceBasis;
+                    loadBasis: MtwUtilizationLoadBasis;
+                    capacityBasis: MtwUtilizationCapacityBasis;
+                };
+            }>;
+        };
+    };
+};
+export declare const UtilizationVehicleFragmentDoc: import('graphql').DocumentNode;
+export declare const UtilizationRouteFragmentDoc: import('graphql').DocumentNode;
+export declare const UtilizationMetricFragmentDoc: import('graphql').DocumentNode;
+export declare const UtilizationReportFragmentDoc: import('graphql').DocumentNode;
+export declare const UtilizationRoutesDocument: import('graphql').DocumentNode;
+export declare const UtilizationCurrentRouteDocument: import('graphql').DocumentNode;
+export declare const UtilizationCurrentVehicleDocument: import('graphql').DocumentNode;
+export declare const UtilizationReportsDocument: import('graphql').DocumentNode;
+export declare const RecordUtilizationReportDocument: import('graphql').DocumentNode;