@burdenoff/microfe-movethewheels 2026.930.4 → 2026.1010.1

package/dist/generated/free-time-operations.d.ts

@@ -0,0 +1,938 @@
+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;
+    };
+};
+export type MtwContainer = {
+    __typename?: 'MtwContainer';
+    containerNumber: Scalars['String']['output'];
+    createdAt: Scalars['DateTime']['output'];
+    equipmentType: MtwEquipmentType;
+    id: Scalars['ID']['output'];
+    ownerName?: Maybe<Scalars['String']['output']>;
+    source: Scalars['String']['output'];
+    suppliedContainerNumber: Scalars['String']['output'];
+};
+export type MtwContainerCycle = {
+    __typename?: 'MtwContainerCycle';
+    bookingReference?: Maybe<Scalars['String']['output']>;
+    closedAt?: Maybe<Scalars['DateTime']['output']>;
+    containerId: Scalars['ID']['output'];
+    createdAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    openedAt: Scalars['DateTime']['output'];
+    shipmentId?: Maybe<Scalars['ID']['output']>;
+    status: MtwContainerCycleStatus;
+    updatedAt: Scalars['DateTime']['output'];
+    version: Scalars['Int']['output'];
+};
+export type MtwContainerCyclePage = {
+    __typename?: 'MtwContainerCyclePage';
+    hasMore: Scalars['Boolean']['output'];
+    items: Array<MtwContainerCycle>;
+    limit: Scalars['Int']['output'];
+    nextOffset?: Maybe<Scalars['Int']['output']>;
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type MtwContainerCycleStatus = 'CLOSED' | 'OPEN';
+/** Append-only sourced observation. Planned/estimated observations never establish custody. */
+export type MtwContainerEvent = {
+    __typename?: 'MtwContainerEvent';
+    actorId: Scalars['ID']['output'];
+    cycleId: Scalars['ID']['output'];
+    eventType: MtwContainerEventType;
+    evidenceNote?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    idempotencyKey: Scalars['String']['output'];
+    kind: MtwContainerEventKind;
+    location?: Maybe<Scalars['String']['output']>;
+    occurredAt: Scalars['DateTime']['output'];
+    receivedAt: Scalars['DateTime']['output'];
+    source: Scalars['String']['output'];
+    sourceReference?: Maybe<Scalars['String']['output']>;
+};
+export type MtwContainerEventKind = 'ACTUAL' | 'ESTIMATED' | 'PLANNED';
+export type MtwContainerEventPage = {
+    __typename?: 'MtwContainerEventPage';
+    hasMore: Scalars['Boolean']['output'];
+    items: Array<MtwContainerEvent>;
+    limit: Scalars['Int']['output'];
+    nextOffset?: Maybe<Scalars['Int']['output']>;
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type MtwContainerEventType = 'AVAILABLE_FOR_PICKUP' | 'DELIVERED' | 'DISCHARGED' | 'EMPTY_READY' | 'EMPTY_RETURNED' | 'GATE_IN' | 'GATE_OUT' | 'LOADED' | 'POSITION_UPDATE' | 'RETURN_ACCEPTED' | 'RETURN_REQUESTED';
+/** 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 MtwContainerPage = {
+    __typename?: 'MtwContainerPage';
+    hasMore: Scalars['Boolean']['output'];
+    items: Array<MtwContainer>;
+    limit: Scalars['Int']['output'];
+    nextOffset?: Maybe<Scalars['Int']['output']>;
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type MtwContainerPagination = {
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+};
+/** Physical equipment; LCL is a freight service, not an equipment type. */
+export type MtwEquipmentType = 'DRY_20' | 'DRY_40' | 'FLAT_RACK' | 'HIGH_CUBE_40' | 'OPEN_TOP' | 'OTHER' | 'REEFER_20' | 'REEFER_40' | 'TANK';
+export type MtwFreeTimeAgreement = {
+    __typename?: 'MtwFreeTimeAgreement';
+    applicability: MtwFreeTimeApplicability;
+    changeReason: Scalars['String']['output'];
+    clockId: Scalars['ID']['output'];
+    confirmedFreeUntil?: Maybe<Scalars['DateTime']['output']>;
+    createdBy: Scalars['ID']['output'];
+    effectiveAt: Scalars['DateTime']['output'];
+    evidence: Array<MtwContainerEvidence>;
+    id: Scalars['ID']['output'];
+    payee: Scalars['String']['output'];
+    payer: Scalars['String']['output'];
+    recordedAt: Scalars['DateTime']['output'];
+    sourceReference: Scalars['String']['output'];
+    stopEventId?: Maybe<Scalars['ID']['output']>;
+    stopEventType: MtwContainerEventType;
+    terms?: Maybe<MtwFreeTimeTerms>;
+    triggerEventId?: Maybe<Scalars['ID']['output']>;
+    triggerEventType: MtwContainerEventType;
+    version: Scalars['Int']['output'];
+};
+/** Full immutable replacement: corrections retain prior evidence and event bindings. */
+export type MtwFreeTimeAgreementInput = {
+    applicability: MtwFreeTimeApplicability;
+    changeReason: Scalars['String']['input'];
+    confirmedFreeUntil?: InputMaybe<Scalars['DateTime']['input']>;
+    effectiveAt: Scalars['DateTime']['input'];
+    evidence: Array<MtwContainerEvidenceInput>;
+    payee: Scalars['String']['input'];
+    payer: Scalars['String']['input'];
+    sourceReference: Scalars['String']['input'];
+    stopEventId?: InputMaybe<Scalars['ID']['input']>;
+    stopEventType: MtwContainerEventType;
+    terms?: InputMaybe<MtwFreeTimeTermsInput>;
+    triggerEventId?: InputMaybe<Scalars['ID']['input']>;
+    triggerEventType: MtwContainerEventType;
+};
+export type MtwFreeTimeAgreementPage = {
+    __typename?: 'MtwFreeTimeAgreementPage';
+    hasMore: Scalars['Boolean']['output'];
+    items: Array<MtwFreeTimeAgreement>;
+    limit: Scalars['Int']['output'];
+    nextOffset?: Maybe<Scalars['Int']['output']>;
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+/** Segmented prospective tariffs need a separate accrual engine. */
+export type MtwFreeTimeApplicability = 'UNSUPPORTED_SEGMENTED' | 'WHOLE_CLOCK';
+export type MtwFreeTimeCalculationPolicy = 'LOCAL_DATE_END' | 'UNSUPPORTED';
+export type MtwFreeTimeCalendar = {
+    __typename?: 'MtwFreeTimeCalendar';
+    excludedDates: Array<Scalars['String']['output']>;
+    weekdays: Array<Scalars['Int']['output']>;
+};
+export type MtwFreeTimeCalendarInput = {
+    excludedDates: Array<Scalars['String']['input']>;
+    weekdays: Array<Scalars['Int']['input']>;
+};
+export type MtwFreeTimeChargeKind = 'DEMURRAGE' | 'DETENTION' | 'TERMINAL_STORAGE';
+export type MtwFreeTimeClock = {
+    __typename?: 'MtwFreeTimeClock';
+    chargeKind: MtwFreeTimeChargeKind;
+    createdAt: Scalars['DateTime']['output'];
+    currentAgreementVersion: Scalars['Int']['output'];
+    cycleId: Scalars['ID']['output'];
+    id: Scalars['ID']['output'];
+    obligationReference: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    version: Scalars['Int']['output'];
+};
+export type MtwFreeTimeClockPage = {
+    __typename?: 'MtwFreeTimeClockPage';
+    hasMore: Scalars['Boolean']['output'];
+    items: Array<MtwFreeTimeClock>;
+    limit: Scalars['Int']['output'];
+    nextOffset?: Maybe<Scalars['Int']['output']>;
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type MtwFreeTimeDecisionKind = 'ACCEPTED' | 'EXPIRED' | 'REJECTED';
+/** Recalculated using recorded versions effective at asOf; not a reconstruction of what was known then. */
+export type MtwFreeTimeExposure = {
+    __typename?: 'MtwFreeTimeExposure';
+    agreementId?: Maybe<Scalars['ID']['output']>;
+    amountMinorUnits?: Maybe<Scalars['Float']['output']>;
+    asOf: Scalars['DateTime']['output'];
+    chargedDays?: Maybe<Scalars['Int']['output']>;
+    clockId: Scalars['ID']['output'];
+    currency?: Maybe<Scalars['String']['output']>;
+    deadlineSource?: Maybe<Scalars['String']['output']>;
+    evaluatedUntil?: Maybe<Scalars['DateTime']['output']>;
+    freeUntil?: Maybe<Scalars['DateTime']['output']>;
+    localLastFreeDate?: Maybe<Scalars['String']['output']>;
+    minorUnitDigits?: Maybe<Scalars['Int']['output']>;
+    reason?: Maybe<Scalars['String']['output']>;
+    status: Scalars['String']['output'];
+};
+/** No decision means requested; expiry alone never changes an accepted agreement. */
+export type MtwFreeTimeExtension = {
+    __typename?: 'MtwFreeTimeExtension';
+    baseAgreementId: Scalars['ID']['output'];
+    clockId: Scalars['ID']['output'];
+    createdBy: Scalars['ID']['output'];
+    decision?: Maybe<MtwFreeTimeExtensionDecision>;
+    evidence: Array<MtwContainerEvidence>;
+    expiresAt: Scalars['DateTime']['output'];
+    id: Scalars['ID']['output'];
+    reason: Scalars['String']['output'];
+    recordedAt: Scalars['DateTime']['output'];
+    requestedAt: Scalars['DateTime']['output'];
+    requestedFreeUntil: Scalars['DateTime']['output'];
+};
+export type MtwFreeTimeExtensionDecision = {
+    __typename?: 'MtwFreeTimeExtensionDecision';
+    acceptedFreeUntil?: Maybe<Scalars['DateTime']['output']>;
+    counterparty: Scalars['String']['output'];
+    createdBy: Scalars['ID']['output'];
+    decidedAt: Scalars['DateTime']['output'];
+    decision: MtwFreeTimeDecisionKind;
+    effectiveAt?: Maybe<Scalars['DateTime']['output']>;
+    evidence: Array<MtwContainerEvidence>;
+    extensionId: Scalars['ID']['output'];
+    id: Scalars['ID']['output'];
+    newAgreementId?: Maybe<Scalars['ID']['output']>;
+    note: Scalars['String']['output'];
+    recordedAt: Scalars['DateTime']['output'];
+    sourceReference: Scalars['String']['output'];
+};
+export type MtwFreeTimeExtensionPage = {
+    __typename?: 'MtwFreeTimeExtensionPage';
+    hasMore: Scalars['Boolean']['output'];
+    items: Array<MtwFreeTimeExtension>;
+    limit: Scalars['Int']['output'];
+    nextOffset?: Maybe<Scalars['Int']['output']>;
+    offset: Scalars['Int']['output'];
+    total: Scalars['Int']['output'];
+};
+export type MtwFreeTimePartialDayPolicy = 'ANY_STARTED_LOCAL_DATE' | 'UNSUPPORTED';
+export type MtwFreeTimeRateTier = {
+    __typename?: 'MtwFreeTimeRateTier';
+    dailyMinorUnits: Scalars['Int']['output'];
+    fromDay: Scalars['Int']['output'];
+    throughDay?: Maybe<Scalars['Int']['output']>;
+};
+export type MtwFreeTimeRateTierInput = {
+    dailyMinorUnits: Scalars['Int']['input'];
+    fromDay: Scalars['Int']['input'];
+    throughDay?: InputMaybe<Scalars['Int']['input']>;
+};
+export type MtwFreeTimeTerms = {
+    __typename?: 'MtwFreeTimeTerms';
+    calculationPolicy: MtwFreeTimeCalculationPolicy;
+    chargeCalendar: MtwFreeTimeCalendar;
+    currency: Scalars['String']['output'];
+    freeCalendar: MtwFreeTimeCalendar;
+    freeDays: Scalars['Int']['output'];
+    includeTriggerDate: Scalars['Boolean']['output'];
+    minorUnitDigits: Scalars['Int']['output'];
+    partialDayPolicy: MtwFreeTimePartialDayPolicy;
+    rateTiers: Array<MtwFreeTimeRateTier>;
+    tierBasis: MtwFreeTimeTierBasis;
+    timeZone: Scalars['String']['output'];
+};
+export type MtwFreeTimeTermsInput = {
+    calculationPolicy: MtwFreeTimeCalculationPolicy;
+    chargeCalendar: MtwFreeTimeCalendarInput;
+    currency: Scalars['String']['input'];
+    freeCalendar: MtwFreeTimeCalendarInput;
+    freeDays: Scalars['Int']['input'];
+    includeTriggerDate: Scalars['Boolean']['input'];
+    minorUnitDigits: Scalars['Int']['input'];
+    partialDayPolicy: MtwFreeTimePartialDayPolicy;
+    rateTiers: Array<MtwFreeTimeRateTierInput>;
+    tierBasis: MtwFreeTimeTierBasis;
+    timeZone: Scalars['String']['input'];
+};
+export type MtwFreeTimeTierBasis = 'CHARGED_DAYS' | 'UNSUPPORTED';
+export type Mutation = {
+    __typename?: 'Mutation';
+    openMtwFreeTimeClock: MtwFreeTimeClock;
+    recordMtwFreeTimeAgreement: MtwFreeTimeAgreement;
+    recordMtwFreeTimeExtensionDecision: MtwFreeTimeExtensionDecision;
+    requestMtwFreeTimeExtension: MtwFreeTimeExtension;
+};
+export type MutationOpenMtwFreeTimeClockArgs = {
+    input: OpenMtwFreeTimeClockInput;
+};
+export type MutationRecordMtwFreeTimeAgreementArgs = {
+    input: RecordMtwFreeTimeAgreementInput;
+};
+export type MutationRecordMtwFreeTimeExtensionDecisionArgs = {
+    input: RecordMtwFreeTimeExtensionDecisionInput;
+};
+export type MutationRequestMtwFreeTimeExtensionArgs = {
+    input: RequestMtwFreeTimeExtensionInput;
+};
+export type OpenMtwFreeTimeClockInput = {
+    agreement: MtwFreeTimeAgreementInput;
+    chargeKind: MtwFreeTimeChargeKind;
+    cycleId: Scalars['ID']['input'];
+    idempotencyKey: Scalars['String']['input'];
+    obligationReference: Scalars['String']['input'];
+};
+export type Query = {
+    __typename?: 'Query';
+    mtwContainerCyclePage: MtwContainerCyclePage;
+    mtwContainerEventPage: MtwContainerEventPage;
+    mtwContainerPage: MtwContainerPage;
+    mtwFreeTimeAgreementPage: MtwFreeTimeAgreementPage;
+    mtwFreeTimeClockPage: MtwFreeTimeClockPage;
+    mtwFreeTimeExposure: MtwFreeTimeExposure;
+    mtwFreeTimeExtensionPage: MtwFreeTimeExtensionPage;
+};
+export type QueryMtwContainerCyclePageArgs = {
+    containerId: Scalars['ID']['input'];
+    pagination?: InputMaybe<MtwContainerPagination>;
+};
+export type QueryMtwContainerEventPageArgs = {
+    cycleId: Scalars['ID']['input'];
+    pagination?: InputMaybe<MtwContainerPagination>;
+};
+export type QueryMtwContainerPageArgs = {
+    pagination?: InputMaybe<MtwContainerPagination>;
+    search?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryMtwFreeTimeAgreementPageArgs = {
+    clockId: Scalars['ID']['input'];
+    pagination?: InputMaybe<MtwContainerPagination>;
+};
+export type QueryMtwFreeTimeClockPageArgs = {
+    cycleId: Scalars['ID']['input'];
+    pagination?: InputMaybe<MtwContainerPagination>;
+};
+export type QueryMtwFreeTimeExposureArgs = {
+    asOf: Scalars['DateTime']['input'];
+    clockId: Scalars['ID']['input'];
+};
+export type QueryMtwFreeTimeExtensionPageArgs = {
+    clockId: Scalars['ID']['input'];
+    pagination?: InputMaybe<MtwContainerPagination>;
+};
+export type RecordMtwFreeTimeAgreementInput = {
+    agreement: MtwFreeTimeAgreementInput;
+    clockId: Scalars['ID']['input'];
+    expectedVersion: Scalars['Int']['input'];
+    idempotencyKey: Scalars['String']['input'];
+};
+export type RecordMtwFreeTimeExtensionDecisionInput = {
+    acceptedFreeUntil?: InputMaybe<Scalars['DateTime']['input']>;
+    counterparty: Scalars['String']['input'];
+    decidedAt: Scalars['DateTime']['input'];
+    decision: MtwFreeTimeDecisionKind;
+    effectiveAt?: InputMaybe<Scalars['DateTime']['input']>;
+    evidence: Array<MtwContainerEvidenceInput>;
+    expectedVersion: Scalars['Int']['input'];
+    extensionId: Scalars['ID']['input'];
+    idempotencyKey: Scalars['String']['input'];
+    note: Scalars['String']['input'];
+    sourceReference: Scalars['String']['input'];
+};
+export type RequestMtwFreeTimeExtensionInput = {
+    baseAgreementId: Scalars['ID']['input'];
+    clockId: Scalars['ID']['input'];
+    evidence: Array<MtwContainerEvidenceInput>;
+    expectedVersion: Scalars['Int']['input'];
+    expiresAt: Scalars['DateTime']['input'];
+    idempotencyKey: Scalars['String']['input'];
+    reason: Scalars['String']['input'];
+    requestedAt: Scalars['DateTime']['input'];
+    requestedFreeUntil: Scalars['DateTime']['input'];
+};
+export type FreeClockFieldsFragment = {
+    __typename?: 'MtwFreeTimeClock';
+    id: string;
+    cycleId: string;
+    chargeKind: MtwFreeTimeChargeKind;
+    obligationReference: string;
+    version: number;
+    currentAgreementVersion: number;
+    createdAt: string;
+    updatedAt: string;
+};
+export type FreeAgreementFieldsFragment = {
+    __typename?: 'MtwFreeTimeAgreement';
+    id: string;
+    clockId: string;
+    version: number;
+    payer: string;
+    payee: string;
+    sourceReference: string;
+    effectiveAt: string;
+    applicability: MtwFreeTimeApplicability;
+    recordedAt: string;
+    triggerEventType: MtwContainerEventType;
+    stopEventType: MtwContainerEventType;
+    triggerEventId?: string | null;
+    stopEventId?: string | null;
+    confirmedFreeUntil?: string | null;
+    changeReason: string;
+    createdBy: string;
+    evidence: Array<{
+        __typename?: 'MtwContainerEvidence';
+        fileId: string;
+        versionId: string;
+        sha256Hash: string;
+        checkedAt: string;
+    }>;
+    terms?: {
+        __typename?: 'MtwFreeTimeTerms';
+        timeZone: string;
+        freeDays: number;
+        includeTriggerDate: boolean;
+        currency: string;
+        minorUnitDigits: number;
+        calculationPolicy: MtwFreeTimeCalculationPolicy;
+        partialDayPolicy: MtwFreeTimePartialDayPolicy;
+        tierBasis: MtwFreeTimeTierBasis;
+        freeCalendar: {
+            __typename?: 'MtwFreeTimeCalendar';
+            weekdays: Array<number>;
+            excludedDates: Array<string>;
+        };
+        chargeCalendar: {
+            __typename?: 'MtwFreeTimeCalendar';
+            weekdays: Array<number>;
+            excludedDates: Array<string>;
+        };
+        rateTiers: Array<{
+            __typename?: 'MtwFreeTimeRateTier';
+            fromDay: number;
+            throughDay?: number | null;
+            dailyMinorUnits: number;
+        }>;
+    } | null;
+};
+export type FreeDecisionFieldsFragment = {
+    __typename?: 'MtwFreeTimeExtensionDecision';
+    id: string;
+    extensionId: string;
+    decision: MtwFreeTimeDecisionKind;
+    decidedAt: string;
+    effectiveAt?: string | null;
+    acceptedFreeUntil?: string | null;
+    newAgreementId?: string | null;
+    counterparty: string;
+    sourceReference: string;
+    note: string;
+    recordedAt: string;
+    createdBy: string;
+    evidence: Array<{
+        __typename?: 'MtwContainerEvidence';
+        fileId: string;
+        versionId: string;
+        sha256Hash: string;
+        checkedAt: string;
+    }>;
+};
+export type FreeExtensionFieldsFragment = {
+    __typename?: 'MtwFreeTimeExtension';
+    id: string;
+    clockId: string;
+    baseAgreementId: string;
+    requestedFreeUntil: string;
+    requestedAt: string;
+    expiresAt: string;
+    reason: string;
+    recordedAt: string;
+    createdBy: string;
+    evidence: Array<{
+        __typename?: 'MtwContainerEvidence';
+        fileId: string;
+        versionId: string;
+        sha256Hash: string;
+        checkedAt: string;
+    }>;
+    decision?: {
+        __typename?: 'MtwFreeTimeExtensionDecision';
+        id: string;
+        extensionId: string;
+        decision: MtwFreeTimeDecisionKind;
+        decidedAt: string;
+        effectiveAt?: string | null;
+        acceptedFreeUntil?: string | null;
+        newAgreementId?: string | null;
+        counterparty: string;
+        sourceReference: string;
+        note: string;
+        recordedAt: string;
+        createdBy: string;
+        evidence: Array<{
+            __typename?: 'MtwContainerEvidence';
+            fileId: string;
+            versionId: string;
+            sha256Hash: string;
+            checkedAt: string;
+        }>;
+    } | null;
+};
+export type FreeContainersQueryVariables = Exact<{
+    pagination: MtwContainerPagination;
+}>;
+export type FreeContainersQuery = {
+    __typename?: 'Query';
+    mtwContainerPage: {
+        __typename?: 'MtwContainerPage';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextOffset?: number | null;
+        items: Array<{
+            __typename?: 'MtwContainer';
+            id: string;
+            containerNumber: string;
+        }>;
+    };
+};
+export type FreeCyclesQueryVariables = Exact<{
+    containerId: Scalars['ID']['input'];
+    pagination: MtwContainerPagination;
+}>;
+export type FreeCyclesQuery = {
+    __typename?: 'Query';
+    mtwContainerCyclePage: {
+        __typename?: 'MtwContainerCyclePage';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextOffset?: number | null;
+        items: Array<{
+            __typename?: 'MtwContainerCycle';
+            id: string;
+            openedAt: string;
+            status: MtwContainerCycleStatus;
+            bookingReference?: string | null;
+        }>;
+    };
+};
+export type FreeEventsQueryVariables = Exact<{
+    cycleId: Scalars['ID']['input'];
+    pagination: MtwContainerPagination;
+}>;
+export type FreeEventsQuery = {
+    __typename?: 'Query';
+    mtwContainerEventPage: {
+        __typename?: 'MtwContainerEventPage';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextOffset?: number | null;
+        items: Array<{
+            __typename?: 'MtwContainerEvent';
+            id: string;
+            eventType: MtwContainerEventType;
+            kind: MtwContainerEventKind;
+            occurredAt: string;
+            source: string;
+            sourceReference?: string | null;
+        }>;
+    };
+};
+export type FreeClocksQueryVariables = Exact<{
+    cycleId: Scalars['ID']['input'];
+    pagination: MtwContainerPagination;
+}>;
+export type FreeClocksQuery = {
+    __typename?: 'Query';
+    mtwFreeTimeClockPage: {
+        __typename?: 'MtwFreeTimeClockPage';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextOffset?: number | null;
+        items: Array<{
+            __typename?: 'MtwFreeTimeClock';
+            id: string;
+            cycleId: string;
+            chargeKind: MtwFreeTimeChargeKind;
+            obligationReference: string;
+            version: number;
+            currentAgreementVersion: number;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type FreeAgreementsQueryVariables = Exact<{
+    clockId: Scalars['ID']['input'];
+    pagination: MtwContainerPagination;
+}>;
+export type FreeAgreementsQuery = {
+    __typename?: 'Query';
+    mtwFreeTimeAgreementPage: {
+        __typename?: 'MtwFreeTimeAgreementPage';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextOffset?: number | null;
+        items: Array<{
+            __typename?: 'MtwFreeTimeAgreement';
+            id: string;
+            clockId: string;
+            version: number;
+            payer: string;
+            payee: string;
+            sourceReference: string;
+            effectiveAt: string;
+            applicability: MtwFreeTimeApplicability;
+            recordedAt: string;
+            triggerEventType: MtwContainerEventType;
+            stopEventType: MtwContainerEventType;
+            triggerEventId?: string | null;
+            stopEventId?: string | null;
+            confirmedFreeUntil?: string | null;
+            changeReason: string;
+            createdBy: string;
+            evidence: Array<{
+                __typename?: 'MtwContainerEvidence';
+                fileId: string;
+                versionId: string;
+                sha256Hash: string;
+                checkedAt: string;
+            }>;
+            terms?: {
+                __typename?: 'MtwFreeTimeTerms';
+                timeZone: string;
+                freeDays: number;
+                includeTriggerDate: boolean;
+                currency: string;
+                minorUnitDigits: number;
+                calculationPolicy: MtwFreeTimeCalculationPolicy;
+                partialDayPolicy: MtwFreeTimePartialDayPolicy;
+                tierBasis: MtwFreeTimeTierBasis;
+                freeCalendar: {
+                    __typename?: 'MtwFreeTimeCalendar';
+                    weekdays: Array<number>;
+                    excludedDates: Array<string>;
+                };
+                chargeCalendar: {
+                    __typename?: 'MtwFreeTimeCalendar';
+                    weekdays: Array<number>;
+                    excludedDates: Array<string>;
+                };
+                rateTiers: Array<{
+                    __typename?: 'MtwFreeTimeRateTier';
+                    fromDay: number;
+                    throughDay?: number | null;
+                    dailyMinorUnits: number;
+                }>;
+            } | null;
+        }>;
+    };
+};
+export type FreeExtensionsQueryVariables = Exact<{
+    clockId: Scalars['ID']['input'];
+    pagination: MtwContainerPagination;
+}>;
+export type FreeExtensionsQuery = {
+    __typename?: 'Query';
+    mtwFreeTimeExtensionPage: {
+        __typename?: 'MtwFreeTimeExtensionPage';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextOffset?: number | null;
+        items: Array<{
+            __typename?: 'MtwFreeTimeExtension';
+            id: string;
+            clockId: string;
+            baseAgreementId: string;
+            requestedFreeUntil: string;
+            requestedAt: string;
+            expiresAt: string;
+            reason: string;
+            recordedAt: string;
+            createdBy: string;
+            evidence: Array<{
+                __typename?: 'MtwContainerEvidence';
+                fileId: string;
+                versionId: string;
+                sha256Hash: string;
+                checkedAt: string;
+            }>;
+            decision?: {
+                __typename?: 'MtwFreeTimeExtensionDecision';
+                id: string;
+                extensionId: string;
+                decision: MtwFreeTimeDecisionKind;
+                decidedAt: string;
+                effectiveAt?: string | null;
+                acceptedFreeUntil?: string | null;
+                newAgreementId?: string | null;
+                counterparty: string;
+                sourceReference: string;
+                note: string;
+                recordedAt: string;
+                createdBy: string;
+                evidence: Array<{
+                    __typename?: 'MtwContainerEvidence';
+                    fileId: string;
+                    versionId: string;
+                    sha256Hash: string;
+                    checkedAt: string;
+                }>;
+            } | null;
+        }>;
+    };
+};
+export type FreeExposureQueryVariables = Exact<{
+    clockId: Scalars['ID']['input'];
+    asOf: Scalars['DateTime']['input'];
+}>;
+export type FreeExposureQuery = {
+    __typename?: 'Query';
+    mtwFreeTimeExposure: {
+        __typename?: 'MtwFreeTimeExposure';
+        clockId: string;
+        agreementId?: string | null;
+        asOf: string;
+        status: string;
+        reason?: string | null;
+        freeUntil?: string | null;
+        evaluatedUntil?: string | null;
+        localLastFreeDate?: string | null;
+        chargedDays?: number | null;
+        amountMinorUnits?: number | null;
+        currency?: string | null;
+        minorUnitDigits?: number | null;
+        deadlineSource?: string | null;
+    };
+};
+export type OpenFreeClockMutationVariables = Exact<{
+    input: OpenMtwFreeTimeClockInput;
+}>;
+export type OpenFreeClockMutation = {
+    __typename?: 'Mutation';
+    openMtwFreeTimeClock: {
+        __typename?: 'MtwFreeTimeClock';
+        id: string;
+        cycleId: string;
+        chargeKind: MtwFreeTimeChargeKind;
+        obligationReference: string;
+        version: number;
+        currentAgreementVersion: number;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type RecordFreeAgreementMutationVariables = Exact<{
+    input: RecordMtwFreeTimeAgreementInput;
+}>;
+export type RecordFreeAgreementMutation = {
+    __typename?: 'Mutation';
+    recordMtwFreeTimeAgreement: {
+        __typename?: 'MtwFreeTimeAgreement';
+        id: string;
+        clockId: string;
+        version: number;
+        payer: string;
+        payee: string;
+        sourceReference: string;
+        effectiveAt: string;
+        applicability: MtwFreeTimeApplicability;
+        recordedAt: string;
+        triggerEventType: MtwContainerEventType;
+        stopEventType: MtwContainerEventType;
+        triggerEventId?: string | null;
+        stopEventId?: string | null;
+        confirmedFreeUntil?: string | null;
+        changeReason: string;
+        createdBy: string;
+        evidence: Array<{
+            __typename?: 'MtwContainerEvidence';
+            fileId: string;
+            versionId: string;
+            sha256Hash: string;
+            checkedAt: string;
+        }>;
+        terms?: {
+            __typename?: 'MtwFreeTimeTerms';
+            timeZone: string;
+            freeDays: number;
+            includeTriggerDate: boolean;
+            currency: string;
+            minorUnitDigits: number;
+            calculationPolicy: MtwFreeTimeCalculationPolicy;
+            partialDayPolicy: MtwFreeTimePartialDayPolicy;
+            tierBasis: MtwFreeTimeTierBasis;
+            freeCalendar: {
+                __typename?: 'MtwFreeTimeCalendar';
+                weekdays: Array<number>;
+                excludedDates: Array<string>;
+            };
+            chargeCalendar: {
+                __typename?: 'MtwFreeTimeCalendar';
+                weekdays: Array<number>;
+                excludedDates: Array<string>;
+            };
+            rateTiers: Array<{
+                __typename?: 'MtwFreeTimeRateTier';
+                fromDay: number;
+                throughDay?: number | null;
+                dailyMinorUnits: number;
+            }>;
+        } | null;
+    };
+};
+export type RequestFreeExtensionMutationVariables = Exact<{
+    input: RequestMtwFreeTimeExtensionInput;
+}>;
+export type RequestFreeExtensionMutation = {
+    __typename?: 'Mutation';
+    requestMtwFreeTimeExtension: {
+        __typename?: 'MtwFreeTimeExtension';
+        id: string;
+        clockId: string;
+        baseAgreementId: string;
+        requestedFreeUntil: string;
+        requestedAt: string;
+        expiresAt: string;
+        reason: string;
+        recordedAt: string;
+        createdBy: string;
+        evidence: Array<{
+            __typename?: 'MtwContainerEvidence';
+            fileId: string;
+            versionId: string;
+            sha256Hash: string;
+            checkedAt: string;
+        }>;
+        decision?: {
+            __typename?: 'MtwFreeTimeExtensionDecision';
+            id: string;
+            extensionId: string;
+            decision: MtwFreeTimeDecisionKind;
+            decidedAt: string;
+            effectiveAt?: string | null;
+            acceptedFreeUntil?: string | null;
+            newAgreementId?: string | null;
+            counterparty: string;
+            sourceReference: string;
+            note: string;
+            recordedAt: string;
+            createdBy: string;
+            evidence: Array<{
+                __typename?: 'MtwContainerEvidence';
+                fileId: string;
+                versionId: string;
+                sha256Hash: string;
+                checkedAt: string;
+            }>;
+        } | null;
+    };
+};
+export type DecideFreeExtensionMutationVariables = Exact<{
+    input: RecordMtwFreeTimeExtensionDecisionInput;
+}>;
+export type DecideFreeExtensionMutation = {
+    __typename?: 'Mutation';
+    recordMtwFreeTimeExtensionDecision: {
+        __typename?: 'MtwFreeTimeExtensionDecision';
+        id: string;
+        extensionId: string;
+        decision: MtwFreeTimeDecisionKind;
+        decidedAt: string;
+        effectiveAt?: string | null;
+        acceptedFreeUntil?: string | null;
+        newAgreementId?: string | null;
+        counterparty: string;
+        sourceReference: string;
+        note: string;
+        recordedAt: string;
+        createdBy: string;
+        evidence: Array<{
+            __typename?: 'MtwContainerEvidence';
+            fileId: string;
+            versionId: string;
+            sha256Hash: string;
+            checkedAt: string;
+        }>;
+    };
+};
+export declare const FreeClockFieldsFragmentDoc: import('graphql').DocumentNode;
+export declare const FreeAgreementFieldsFragmentDoc: import('graphql').DocumentNode;
+export declare const FreeDecisionFieldsFragmentDoc: import('graphql').DocumentNode;
+export declare const FreeExtensionFieldsFragmentDoc: import('graphql').DocumentNode;
+export declare const FreeContainersDocument: import('graphql').DocumentNode;
+export declare const FreeCyclesDocument: import('graphql').DocumentNode;
+export declare const FreeEventsDocument: import('graphql').DocumentNode;
+export declare const FreeClocksDocument: import('graphql').DocumentNode;
+export declare const FreeAgreementsDocument: import('graphql').DocumentNode;
+export declare const FreeExtensionsDocument: import('graphql').DocumentNode;
+export declare const FreeExposureDocument: import('graphql').DocumentNode;
+export declare const OpenFreeClockDocument: import('graphql').DocumentNode;
+export declare const RecordFreeAgreementDocument: import('graphql').DocumentNode;
+export declare const RequestFreeExtensionDocument: import('graphql').DocumentNode;
+export declare const DecideFreeExtensionDocument: import('graphql').DocumentNode;