import { K as IStructure, R as IVersionSummary, e as IBulkCaptureInput, g as IBulkCaptureResponse, j as ICommitListResponse, W as ObservationStatus, x as INote, k as IDraftReadiness, V as INave, u as IGeoUnitsResponse, v as ILineageAuditResponse, y as IObservationTask, H as IRuntimeBoundaryReadiness, r as IFarmsResponse, O as IStructureUploadRequest, P as IStructureUploadResponse, E as IPlantingValidationResponse, z as IPlantingBatchItem, D as IPlantingBatchResponse, Q as IVersionDetail } from '../version.entities-Cn8cc2qP.cjs';
export { I as Bed, B as BulkCaptureStatus, C as CommitChangeAction, a as CommitChangeLevel, F as FarmSize, b as FarmStateConfig, c as FarmType, G as GeoUnitGranularity, d as GeoUnitType, f as IBulkCaptureItem, h as ICommit, i as ICommitChange, l as IFarm, m as IFarmBed, n as IFarmBlock, o as IFarmCell, p as IFarmNaveAlignment, q as IFarmSquare, s as IGeoLocation, t as IGeoUnit, w as ILineageEntry, A as IPlantingBatchItemResult, J as IRuntimeSurfaceSnapshot, L as IStructureBlockPayload, M as IStructureLocationLevel, N as IStructureObservationPayload, S as IdentityQuality, T as LineageClassification, U as LineageConfidence, X as PlantingBatchCode, Y as Square } from '../version.entities-Cn8cc2qP.cjs';
import * as axios from 'axios';

declare function fetchApplyDraftOperations({ blockId, data, }: {
    blockId: string;
    data: {
        baseDraftUpdatedAt?: string;
        operations: Record<string, unknown>[];
    };
}): Promise<axios.AxiosResponse<IStructure, any, {}>>;

declare function fetchBasicVersionsByFarm({ farmId }: {
    farmId: string;
}): Promise<axios.AxiosResponse<IVersionSummary[], any, {}>>;

declare function fetchBulkCapture(items: IBulkCaptureInput[]): Promise<axios.AxiosResponse<IBulkCaptureResponse, any, {}>>;

declare function fetchBulkCaptureStatus({ jobId }: {
    jobId: string;
}): Promise<axios.AxiosResponse<IBulkCaptureResponse, any, {}>>;

declare function fetchCommits({ blockId, limit, offset, }: {
    blockId: string;
    limit?: number;
    offset?: number;
}): Promise<axios.AxiosResponse<ICommitListResponse, any, {}>>;

declare function fetchConfirmStructure({ blockId, implemented, }: {
    blockId: string;
    implemented?: number;
}): Promise<axios.AxiosResponse<IStructure, any, {}>>;

declare function fetchConfirmedStructures({ _id }: {
    _id: string;
}): Promise<axios.AxiosResponse<IStructure[], any, {}>>;

interface ICreateObservationInput {
    farmId: string;
    blockId: string;
    level: string;
    message: string;
    entityId?: string;
    status?: ObservationStatus;
    createdBy?: string;
}
declare function fetchCreateObservation(data: ICreateObservationInput): Promise<axios.AxiosResponse<INote, any, {}>>;

declare function fetchCreateStructure(data: Partial<IStructure>): Promise<axios.AxiosResponse<IStructure, any, {}>>;

declare function fetchDraftReadiness({ blockId }: {
    blockId: string;
}): Promise<axios.AxiosResponse<IDraftReadiness, any, {}>>;

declare function fetchDraftsByFarm({ farmId }: {
    farmId: string;
}): Promise<axios.AxiosResponse<IStructure[], any, {}>>;

declare function fetchEditFromConfirmed({ blockId }: {
    blockId: string;
}): Promise<axios.AxiosResponse<IStructure, any, {}>>;

declare function fetchGenerateAlignment(data: Partial<IStructure>): Promise<axios.AxiosResponse<INave[][], any, {}>>;

declare function fetchGeoUnits({ farmId, limit, cursor, asOfDate, blockId, }: {
    farmId: string;
    limit?: number;
    cursor?: string;
    asOfDate?: string;
    blockId?: string;
}): Promise<axios.AxiosResponse<IGeoUnitsResponse, any, {}>>;

declare function fetchLatestConfirmedVersions({ farmId, asOfDate, }: {
    farmId: string;
    asOfDate?: string;
}): Promise<axios.AxiosResponse<IVersionSummary[], any, {}>>;

declare function fetchLatestDraftsByFarm({ farmId }: {
    farmId: string;
}): Promise<axios.AxiosResponse<IStructure[], any, {}>>;

declare function fetchLatestVersionForBlock({ blockId, asOfDate, }: {
    blockId: string;
    asOfDate?: string;
}): Promise<axios.AxiosResponse<IVersionSummary, any, {}>>;

declare function fetchLatestVersionsWithAlignment({ farmId }: {
    farmId: string;
}): Promise<axios.AxiosResponse<IStructure[], any, {}>>;

declare function fetchLineageAuditPreview({ farmId, blockName, mode, limit, }: {
    farmId: string;
    blockName?: string;
    mode?: 'block' | 'leaf';
    limit?: number;
}): Promise<axios.AxiosResponse<ILineageAuditResponse, any, {}>>;

declare function fetchObservationById({ id }: {
    id: string;
}): Promise<axios.AxiosResponse<INote, any, {}>>;

declare function fetchObservationTasks({ blockId }: {
    blockId: string;
}): Promise<axios.AxiosResponse<IObservationTask[], any, {}>>;

declare function fetchObservations({ blockId }: {
    blockId: string;
}): Promise<axios.AxiosResponse<INote[], any, {}>>;

declare function fetchPatchObservationStatus({ id, status, }: {
    id: string;
    status: ObservationStatus;
}): Promise<axios.AxiosResponse<INote, any, {}>>;

declare function fetchRegenerateAlignment({ blockId }: {
    blockId: string;
}): Promise<axios.AxiosResponse<INave[][], any, {}>>;

declare function fetchReplaceDraft({ blockId, data, }: {
    blockId: string;
    data: {
        alignment: unknown[][];
    };
}): Promise<axios.AxiosResponse<IStructure, any, {}>>;

declare function fetchRuntimeBoundaryReadiness(): Promise<axios.AxiosResponse<IRuntimeBoundaryReadiness, any, {}>>;

declare function fetchStructure({ _id }: {
    _id: string;
}): Promise<axios.AxiosResponse<IStructure[], any, {}>>;

declare function fetchStructureById({ _id }: {
    _id: string;
}): Promise<axios.AxiosResponse<IStructure, any, {}>>;

declare function fetchStructureDownload(): Promise<axios.AxiosResponse<IFarmsResponse, any, {}>>;

declare function fetchUpdateBed({ bedId, data, }: {
    bedId: string;
    data: {
        name?: string;
        orderIndex?: number;
    };
}): Promise<axios.AxiosResponse<Record<string, unknown>, any, {}>>;

interface IUpdateBlockInput {
    blockName?: string;
    sides?: number;
    bedsPerNave?: number;
    maxTotalBeds?: number;
    maxTotalNaves?: number;
    centralRoadSize?: number;
    widthBed?: number;
    lengthBed?: number;
    bedRoadSize?: number;
    pointA?: [number, number];
    pointB?: [number, number];
}
declare function fetchUpdateBlock({ blockId, data, }: {
    blockId: string;
    data: IUpdateBlockInput;
}): Promise<axios.AxiosResponse<IStructure, any, {}>>;

declare function fetchUpdateCell({ cellId, data, }: {
    cellId: string;
    data: {
        lineNumber?: number;
        rowNumber?: number;
        colNumber?: number;
    };
}): Promise<axios.AxiosResponse<Record<string, unknown>, any, {}>>;

declare function fetchUpdateNave({ naveId, data, }: {
    naveId: string;
    data: {
        name?: string;
        orderIndex?: number;
    };
}): Promise<axios.AxiosResponse<Record<string, unknown>, any, {}>>;

declare function fetchUpdateSquare({ squareId, data, }: {
    squareId: string;
    data: {
        number?: number;
        orderIndex?: number;
    };
}): Promise<axios.AxiosResponse<Record<string, unknown>, any, {}>>;

declare function fetchUpdateStructure({ id, data, }: {
    id: string;
    data: Partial<IStructure>;
}): Promise<axios.AxiosResponse<IStructure, any, {}>>;

declare function fetchUploadStructure(data: IStructureUploadRequest): Promise<axios.AxiosResponse<IStructureUploadResponse[], any, {}>>;

declare function fetchValidatePlantingUnit({ structureId, structureVersion, geoUnitId, geoUnitType, farmId, }: {
    structureId: string;
    structureVersion: number;
    geoUnitId: string;
    geoUnitType: 'SQUARE' | 'CELL';
    farmId?: string;
}): Promise<axios.AxiosResponse<IPlantingValidationResponse, any, {}>>;

interface IValidatePlantingBatchInput {
    farmId: string;
    items: IPlantingBatchItem[];
    asOfDate?: string;
    requestedStructureVersion?: number;
}
declare function fetchValidatePlantingUnitsBatch(data: IValidatePlantingBatchInput): Promise<axios.AxiosResponse<IPlantingBatchResponse, any, {}>>;

declare function fetchVersionByNumber({ blockId, version, }: {
    blockId: string;
    version: number;
}): Promise<axios.AxiosResponse<IVersionDetail, any, {}>>;

declare function fetchVersionsByBlock({ blockId }: {
    blockId: string;
}): Promise<axios.AxiosResponse<IVersionSummary[], any, {}>>;

export { IBulkCaptureInput, IBulkCaptureResponse, ICommitListResponse, IDraftReadiness, IFarmsResponse, IGeoUnitsResponse, ILineageAuditResponse, INote, IObservationTask, IPlantingBatchItem, IPlantingBatchResponse, IPlantingValidationResponse, IRuntimeBoundaryReadiness, IStructure, IStructureUploadRequest, IStructureUploadResponse, type IUpdateBlockInput, IVersionDetail, IVersionSummary, INave as Nave, ObservationStatus, fetchApplyDraftOperations, fetchBasicVersionsByFarm, fetchBulkCapture, fetchBulkCaptureStatus, fetchCommits, fetchConfirmStructure, fetchConfirmedStructures, fetchCreateObservation, fetchCreateStructure, fetchDraftReadiness, fetchDraftsByFarm, fetchEditFromConfirmed, fetchGenerateAlignment, fetchGeoUnits, fetchLatestConfirmedVersions, fetchLatestDraftsByFarm, fetchLatestVersionForBlock, fetchLatestVersionsWithAlignment, fetchLineageAuditPreview, fetchObservationById, fetchObservationTasks, fetchObservations, fetchPatchObservationStatus, fetchRegenerateAlignment, fetchReplaceDraft, fetchRuntimeBoundaryReadiness, fetchStructure, fetchStructureById, fetchStructureDownload, fetchUpdateBed, fetchUpdateBlock, fetchUpdateCell, fetchUpdateNave, fetchUpdateSquare, fetchUpdateStructure, fetchUploadStructure, fetchValidatePlantingUnit, fetchValidatePlantingUnitsBatch, fetchVersionByNumber, fetchVersionsByBlock };