@arascreative/erp-client 0.0.0-stage → 1.1.0

package/dist/generated/api.d.ts

@@ -0,0 +1,2282 @@
+import type { DataTag, DefinedInitialDataOptions, DefinedUseQueryResult, QueryClient, QueryKey, UndefinedInitialDataOptions, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+export type GetAntiforgeryToken200 = {
+    requestToken: string;
+    headerName: string;
+};
+export type LoginBody = {
+    email: string;
+    passwordPlain: string;
+};
+export type Login200User = {
+    id: string;
+    email: string;
+    username: string;
+    kind: string;
+};
+export type Login200 = {
+    user: Login200User;
+    expiresAt: string;
+    requestToken: string;
+    headerName: string;
+};
+export type Login400Errors = {
+    [key: string]: string[];
+};
+export type Login400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: Login400Errors;
+};
+export type Login401Errors = {
+    [key: string]: string[];
+};
+export type Login401 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: Login401Errors;
+};
+export type Login403Errors = {
+    [key: string]: string[];
+};
+export type Login403 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: Login403Errors;
+};
+export type Login429Errors = {
+    [key: string]: string[];
+};
+export type Login429 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: Login429Errors;
+};
+export type GetCurrentUser200User = {
+    id: string;
+    email: string;
+    username: string;
+    kind: string;
+};
+export type GetCurrentUser200 = {
+    user: GetCurrentUser200User;
+};
+export type GetCurrentUser401Errors = {
+    [key: string]: string[];
+};
+export type GetCurrentUser401 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: GetCurrentUser401Errors;
+};
+export type Logout200 = {
+    requestToken: string;
+    headerName: string;
+};
+export type Logout403Errors = {
+    [key: string]: string[];
+};
+export type Logout403 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: Logout403Errors;
+};
+export type CreateOwnerBody = {
+    email: string;
+    username: string;
+    passwordPlain: string;
+};
+export type CreateOwner201 = {
+    id: string;
+};
+export type CreateOwner400Errors = {
+    [key: string]: string[];
+};
+export type CreateOwner400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CreateOwner400Errors;
+};
+export type CreateOwner403Errors = {
+    [key: string]: string[];
+};
+export type CreateOwner403 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CreateOwner403Errors;
+};
+export type CreateOwner409Errors = {
+    [key: string]: string[];
+};
+export type CreateOwner409 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CreateOwner409Errors;
+};
+export type CreateOwner422Errors = {
+    [key: string]: string[];
+};
+export type CreateOwner422 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CreateOwner422Errors;
+};
+export type SearchAddressesParams = {
+    keyword: string;
+    limit?: number;
+};
+export type SearchAddresses200ItemExternalId = string | null;
+export type SearchAddresses200Item = {
+    addressId: string;
+    externalId: SearchAddresses200ItemExternalId;
+    destinationCode: string;
+    originCode: string;
+    provinceName: string;
+    cityName: string;
+    districtName: string;
+    subDistrictName: string;
+    zipCode: string;
+};
+export type SearchAddresses400Errors = {
+    [key: string]: string[];
+};
+export type SearchAddresses400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: SearchAddresses400Errors;
+};
+export type InitiateUploadBody = {
+    originalName: string;
+    mimeType: string;
+    sizeBytes: number;
+    checksum: string;
+    purpose: string;
+    expiresInSeconds?: number;
+};
+export type InitiateUpload201 = {
+    fileId: string;
+    storageKey: string;
+    presignedUploadUrl: string;
+    expiresInSeconds: number;
+};
+export type InitiateUpload400Errors = {
+    [key: string]: string[];
+};
+export type InitiateUpload400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: InitiateUpload400Errors;
+};
+export type InitiateUpload413Errors = {
+    [key: string]: string[];
+};
+export type InitiateUpload413 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: InitiateUpload413Errors;
+};
+export type InitiateUpload422Errors = {
+    [key: string]: string[];
+};
+export type InitiateUpload422 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: InitiateUpload422Errors;
+};
+export type UploadFileBody = {
+    originalName: string;
+    mimeType: string;
+    contentBase64: string;
+    purpose: string;
+    uploadedBy?: string;
+};
+export type UploadFile201 = {
+    id: string;
+    originalName: string;
+    mimeType: string;
+    sizeBytes: number;
+    checksum: string;
+    status: string;
+    visibility: string;
+    purpose: string;
+    accessUrl: string;
+    expiresAt: string;
+};
+export type UploadFile400Errors = {
+    [key: string]: string[];
+};
+export type UploadFile400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: UploadFile400Errors;
+};
+export type UploadFile413Errors = {
+    [key: string]: string[];
+};
+export type UploadFile413 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: UploadFile413Errors;
+};
+export type UploadFile422Errors = {
+    [key: string]: string[];
+};
+export type UploadFile422 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: UploadFile422Errors;
+};
+export type ToggleWarehouseStatus200 = {
+    isActive: boolean;
+};
+export type ToggleWarehouseStatus404Errors = {
+    [key: string]: string[];
+};
+export type ToggleWarehouseStatus404 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: ToggleWarehouseStatus404Errors;
+};
+export type ChangeStockItemStatusBody = {
+    status: string;
+};
+export type ChangeStockItemStatus200 = {
+    status: string;
+};
+export type ChangeStockItemStatus400Errors = {
+    [key: string]: string[];
+};
+export type ChangeStockItemStatus400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: ChangeStockItemStatus400Errors;
+};
+export type ChangeStockItemStatus404Errors = {
+    [key: string]: string[];
+};
+export type ChangeStockItemStatus404 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: ChangeStockItemStatus404Errors;
+};
+export type CompleteUploadBody = {
+    actualChecksum?: string;
+};
+export type CompleteUpload200 = {
+    id: string;
+    status: string;
+    activatedAt: string;
+};
+export type CompleteUpload400Errors = {
+    [key: string]: string[];
+};
+export type CompleteUpload400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CompleteUpload400Errors;
+};
+export type CompleteUpload404Errors = {
+    [key: string]: string[];
+};
+export type CompleteUpload404 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CompleteUpload404Errors;
+};
+export type CompleteUpload422Errors = {
+    [key: string]: string[];
+};
+export type CompleteUpload422 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CompleteUpload422Errors;
+};
+export type CompleteUpload500Errors = {
+    [key: string]: string[];
+};
+export type CompleteUpload500 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CompleteUpload500Errors;
+};
+export type GetFileAccessUrlParams = {
+    expiresInSeconds?: number;
+};
+export type GetFileAccessUrl200 = {
+    fileId: string;
+    url: string;
+    isPublic: boolean;
+    expiresAt: string;
+};
+export type GetFileAccessUrl400Errors = {
+    [key: string]: string[];
+};
+export type GetFileAccessUrl400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: GetFileAccessUrl400Errors;
+};
+export type GetFileAccessUrl404Errors = {
+    [key: string]: string[];
+};
+export type GetFileAccessUrl404 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: GetFileAccessUrl404Errors;
+};
+export type GetFileAccessUrl422Errors = {
+    [key: string]: string[];
+};
+export type GetFileAccessUrl422 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: GetFileAccessUrl422Errors;
+};
+export type GetWarehouseById200Pic = {
+    name: string;
+    phone: string;
+};
+export type GetWarehouseById200AddressDestinationCode = string | null;
+export type GetWarehouseById200AddressProvinceName = string | null;
+export type GetWarehouseById200AddressCityName = string | null;
+export type GetWarehouseById200AddressDistrictName = string | null;
+export type GetWarehouseById200AddressSubDistrictName = string | null;
+export type GetWarehouseById200AddressZipCode = string | null;
+export type GetWarehouseById200Address = {
+    addressId: string;
+    destinationCode: GetWarehouseById200AddressDestinationCode;
+    provinceName: GetWarehouseById200AddressProvinceName;
+    cityName: GetWarehouseById200AddressCityName;
+    districtName: GetWarehouseById200AddressDistrictName;
+    subDistrictName: GetWarehouseById200AddressSubDistrictName;
+    zipCode: GetWarehouseById200AddressZipCode;
+};
+export type GetWarehouseById200FullAddressText = string | null;
+export type GetWarehouseById200 = {
+    id: string;
+    name: string;
+    pic: GetWarehouseById200Pic;
+    address: GetWarehouseById200Address;
+    fullAddressText: GetWarehouseById200FullAddressText;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+export type GetWarehouseById404Errors = {
+    [key: string]: string[];
+};
+export type GetWarehouseById404 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: GetWarehouseById404Errors;
+};
+export type UpdateWarehouseBodyFullAddressText = string | null;
+export type UpdateWarehouseBody = {
+    name: string;
+    picName: string;
+    picPhone: string;
+    addressId: string;
+    fullAddressText?: UpdateWarehouseBodyFullAddressText;
+};
+export type UpdateWarehouse400Errors = {
+    [key: string]: string[];
+};
+export type UpdateWarehouse400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: UpdateWarehouse400Errors;
+};
+export type UpdateWarehouse404Errors = {
+    [key: string]: string[];
+};
+export type UpdateWarehouse404 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: UpdateWarehouse404Errors;
+};
+export type UpdateWarehouse409Errors = {
+    [key: string]: string[];
+};
+export type UpdateWarehouse409 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: UpdateWarehouse409Errors;
+};
+export type UpdateWarehouse422Errors = {
+    [key: string]: string[];
+};
+export type UpdateWarehouse422 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: UpdateWarehouse422Errors;
+};
+export type DeleteWarehouse400Errors = {
+    [key: string]: string[];
+};
+export type DeleteWarehouse400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: DeleteWarehouse400Errors;
+};
+export type DeleteWarehouse404Errors = {
+    [key: string]: string[];
+};
+export type DeleteWarehouse404 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: DeleteWarehouse404Errors;
+};
+export type DeleteWarehouse409Errors = {
+    [key: string]: string[];
+};
+export type DeleteWarehouse409 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: DeleteWarehouse409Errors;
+};
+export type UpdateStockItemBodyImageFileId = string | null;
+export type UpdateStockItemBody = {
+    name: string;
+    sku: string;
+    imageFileId?: UpdateStockItemBodyImageFileId;
+};
+export type UpdateStockItem400Errors = {
+    [key: string]: string[];
+};
+export type UpdateStockItem400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: UpdateStockItem400Errors;
+};
+export type UpdateStockItem404Errors = {
+    [key: string]: string[];
+};
+export type UpdateStockItem404 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: UpdateStockItem404Errors;
+};
+export type UpdateStockItem409Errors = {
+    [key: string]: string[];
+};
+export type UpdateStockItem409 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: UpdateStockItem409Errors;
+};
+export type DeleteStockItem400Errors = {
+    [key: string]: string[];
+};
+export type DeleteStockItem400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: DeleteStockItem400Errors;
+};
+export type DeleteStockItem404Errors = {
+    [key: string]: string[];
+};
+export type DeleteStockItem404 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: DeleteStockItem404Errors;
+};
+export type DeleteStockItem409Errors = {
+    [key: string]: string[];
+};
+export type DeleteStockItem409 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: DeleteStockItem409Errors;
+};
+export type GetStoredFileById200 = {
+    id: string;
+    originalName: string;
+    mimeType: string;
+    sizeBytes: number;
+    checksum: string;
+    storageKey: string;
+    status: string;
+    visibility: string;
+    purpose: string;
+    uploadedBy: string;
+    expiresAt: string;
+    createdAt: string;
+    activatedAt: string;
+    deletedAt: string;
+};
+export type GetStoredFileById400Errors = {
+    [key: string]: string[];
+};
+export type GetStoredFileById400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: GetStoredFileById400Errors;
+};
+export type GetStoredFileById404Errors = {
+    [key: string]: string[];
+};
+export type GetStoredFileById404 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: GetStoredFileById404Errors;
+};
+export type DeleteStoredFile400Errors = {
+    [key: string]: string[];
+};
+export type DeleteStoredFile400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: DeleteStoredFile400Errors;
+};
+export type DeleteStoredFile404Errors = {
+    [key: string]: string[];
+};
+export type DeleteStoredFile404 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: DeleteStoredFile404Errors;
+};
+export type DeleteStoredFile409Errors = {
+    [key: string]: string[];
+};
+export type DeleteStoredFile409 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: DeleteStoredFile409Errors;
+};
+export type GetHealth200 = {
+    status: string;
+    timestamp: string;
+};
+export type GetHealth503Errors = {
+    [key: string]: string[];
+};
+export type GetHealth503 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: GetHealth503Errors;
+};
+export type CreateWarehouseBodyFullAddressText = string | null;
+export type CreateWarehouseBody = {
+    name: string;
+    picName: string;
+    picPhone: string;
+    addressId: string;
+    fullAddressText?: CreateWarehouseBodyFullAddressText;
+};
+export type CreateWarehouse201 = {
+    id: string;
+};
+export type CreateWarehouse400Errors = {
+    [key: string]: string[];
+};
+export type CreateWarehouse400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CreateWarehouse400Errors;
+};
+export type CreateWarehouse404Errors = {
+    [key: string]: string[];
+};
+export type CreateWarehouse404 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CreateWarehouse404Errors;
+};
+export type CreateWarehouse409Errors = {
+    [key: string]: string[];
+};
+export type CreateWarehouse409 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CreateWarehouse409Errors;
+};
+export type CreateWarehouse422Errors = {
+    [key: string]: string[];
+};
+export type CreateWarehouse422 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CreateWarehouse422Errors;
+};
+export type ListWarehousesParams = {
+    search?: string;
+    isActive?: boolean;
+};
+export type ListWarehouses2000Pic = {
+    name: string;
+    phone: string;
+};
+export type ListWarehouses2000AddressDestinationCode = string | null;
+export type ListWarehouses2000AddressProvinceName = string | null;
+export type ListWarehouses2000AddressCityName = string | null;
+export type ListWarehouses2000AddressDistrictName = string | null;
+export type ListWarehouses2000AddressSubDistrictName = string | null;
+export type ListWarehouses2000AddressZipCode = string | null;
+export type ListWarehouses2000Address = {
+    addressId: string;
+    destinationCode: ListWarehouses2000AddressDestinationCode;
+    provinceName: ListWarehouses2000AddressProvinceName;
+    cityName: ListWarehouses2000AddressCityName;
+    districtName: ListWarehouses2000AddressDistrictName;
+    subDistrictName: ListWarehouses2000AddressSubDistrictName;
+    zipCode: ListWarehouses2000AddressZipCode;
+};
+export type ListWarehouses2000FullAddressText = string | null;
+export type ListWarehouses2000 = {
+    id: string;
+    name: string;
+    pic: ListWarehouses2000Pic;
+    address: ListWarehouses2000Address;
+    fullAddressText: ListWarehouses2000FullAddressText;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+export type ListWarehouses200 = {
+    '0': ListWarehouses2000;
+};
+export type ListStockMovementsParams = {
+    itemId?: string;
+    batchId?: string;
+    warehouseId?: string;
+    page?: number;
+    pageSize?: number;
+    orderBy?: string;
+    descending?: boolean;
+};
+export type ListStockMovements200ItemsItemBatchId = string | null;
+export type ListStockMovements200ItemsItemSourceReferenceId = string | null;
+export type ListStockMovements200ItemsItemExternalReferenceNo = string | null;
+export type ListStockMovements200ItemsItemNote = string | null;
+export type ListStockMovements200ItemsItemRecordedBy = string | null;
+export type ListStockMovements200ItemsItemReceivedBy = string | null;
+export type ListStockMovements200ItemsItem = {
+    id: string;
+    itemId: string;
+    itemName: string;
+    warehouseId: string;
+    warehouseName: string;
+    batchId: ListStockMovements200ItemsItemBatchId;
+    direction: string;
+    quantity: number;
+    sourceType: string;
+    sourceReferenceId: ListStockMovements200ItemsItemSourceReferenceId;
+    externalReferenceNo: ListStockMovements200ItemsItemExternalReferenceNo;
+    note: ListStockMovements200ItemsItemNote;
+    createdAt: string;
+    recordedBy: ListStockMovements200ItemsItemRecordedBy;
+    receivedBy: ListStockMovements200ItemsItemReceivedBy;
+};
+export type ListStockMovements200 = {
+    items: ListStockMovements200ItemsItem[];
+    page: number;
+    pageSize: number;
+    totalCount: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+};
+export type CreateStockItemBodyImageFileId = string | null;
+export type CreateStockItemBody = {
+    name: string;
+    sku: string;
+    imageFileId?: CreateStockItemBodyImageFileId;
+};
+export type CreateStockItem201 = {
+    id: string;
+};
+export type CreateStockItem400Errors = {
+    [key: string]: string[];
+};
+export type CreateStockItem400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CreateStockItem400Errors;
+};
+export type CreateStockItem409Errors = {
+    [key: string]: string[];
+};
+export type CreateStockItem409 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CreateStockItem409Errors;
+};
+export type ListStockItemsParams = {
+    warehouseId?: string;
+    search?: string;
+    isActive?: boolean;
+    page?: number;
+    pageSize?: number;
+    orderBy?: string;
+    descending?: boolean;
+};
+export type ListStockItems200ItemsItem = {
+    id: string;
+    sku: string;
+    name: string;
+    isActive: boolean;
+    onHandQty: number;
+    reservedQty: number;
+    availableQty: number;
+};
+export type ListStockItems200 = {
+    items: ListStockItems200ItemsItem[];
+    page: number;
+    pageSize: number;
+    totalCount: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+};
+export type CreateBatchBodyExpiresOn = string | null;
+export type CreateBatchBodyExternalReferenceNo = string | null;
+export type CreateBatchBodyNote = string | null;
+export type CreateBatchBodyReceivedBy = string | null;
+export type CreateBatchBodyRecordedBy = string | null;
+export type CreateBatchBody = {
+    itemId: string;
+    warehouseId: string;
+    receivedAt: string;
+    receivedQty: number;
+    sourceType: string;
+    unitCost: number;
+    expiresOn?: CreateBatchBodyExpiresOn;
+    externalReferenceNo?: CreateBatchBodyExternalReferenceNo;
+    note?: CreateBatchBodyNote;
+    receivedBy?: CreateBatchBodyReceivedBy;
+    recordedBy?: CreateBatchBodyRecordedBy;
+};
+export type CreateBatch201 = {
+    id: string;
+};
+export type CreateBatch400Errors = {
+    [key: string]: string[];
+};
+export type CreateBatch400 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CreateBatch400Errors;
+};
+export type CreateBatch404Errors = {
+    [key: string]: string[];
+};
+export type CreateBatch404 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CreateBatch404Errors;
+};
+export type CreateBatch409Errors = {
+    [key: string]: string[];
+};
+export type CreateBatch409 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: CreateBatch409Errors;
+};
+export type Get200 = {
+    message: string;
+};
+export type Get503Errors = {
+    [key: string]: string[];
+};
+export type Get503 = {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    errors?: Get503Errors;
+};
+/**
+ * Stores an HttpOnly antiforgery cookie and returns the request token and header name. Send both on subsequent identity requests that change data.
+ * @summary Get an antiforgery token
+ */
+export type getAntiforgeryTokenResponse200 = {
+    data: GetAntiforgeryToken200;
+    status: 200;
+};
+export type getAntiforgeryTokenResponseSuccess = (getAntiforgeryTokenResponse200) & {
+    headers: Headers;
+};
+export type getAntiforgeryTokenResponse = (getAntiforgeryTokenResponseSuccess);
+export declare const getGetAntiforgeryTokenUrl: () => string;
+export declare const getAntiforgeryToken: (options?: RequestInit) => Promise<getAntiforgeryTokenResponse>;
+export declare const getGetAntiforgeryTokenQueryKey: () => readonly ["/identity/antiforgery"];
+export declare const getGetAntiforgeryTokenQueryOptions: <TData = Awaited<ReturnType<typeof getAntiforgeryToken>>, TError = unknown>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getAntiforgeryToken>>, TError, TData>>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getAntiforgeryToken>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type GetAntiforgeryTokenQueryResult = NonNullable<Awaited<ReturnType<typeof getAntiforgeryToken>>>;
+export type GetAntiforgeryTokenQueryError = unknown;
+export declare function useGetAntiforgeryToken<TData = Awaited<ReturnType<typeof getAntiforgeryToken>>, TError = unknown>(options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getAntiforgeryToken>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof getAntiforgeryToken>>, TError, Awaited<ReturnType<typeof getAntiforgeryToken>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetAntiforgeryToken<TData = Awaited<ReturnType<typeof getAntiforgeryToken>>, TError = unknown>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getAntiforgeryToken>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof getAntiforgeryToken>>, TError, Awaited<ReturnType<typeof getAntiforgeryToken>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetAntiforgeryToken<TData = Awaited<ReturnType<typeof getAntiforgeryToken>>, TError = unknown>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getAntiforgeryToken>>, TError, TData>>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * Creates a new server-side session with the configured absolute lifetime and rotates the antiforgery token. Use the returned requestToken for subsequent requests.
+ * @summary Sign in with email and password
+ */
+export type loginResponse200 = {
+    data: Login200;
+    status: 200;
+};
+export type loginResponse400 = {
+    data: Login400;
+    status: 400;
+};
+export type loginResponse401 = {
+    data: Login401;
+    status: 401;
+};
+export type loginResponse403 = {
+    data: Login403;
+    status: 403;
+};
+export type loginResponse429 = {
+    data: Login429;
+    status: 429;
+};
+export type loginResponseSuccess = (loginResponse200) & {
+    headers: Headers;
+};
+export type loginResponseError = (loginResponse400 | loginResponse401 | loginResponse403 | loginResponse429) & {
+    headers: Headers;
+};
+export type loginResponse = (loginResponseSuccess | loginResponseError);
+export declare const getLoginUrl: () => string;
+export declare const login: (loginBody: LoginBody, options?: RequestInit) => Promise<loginResponse>;
+export declare const getLoginMutationOptions: <TError = Login400 | Login401 | Login403 | Login429, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof login>>, TError, {
+        data: LoginBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof login>>, TError, {
+    data: LoginBody;
+}, TContext>;
+export type LoginMutationResult = NonNullable<Awaited<ReturnType<typeof login>>>;
+export type LoginMutationBody = LoginBody;
+export type LoginMutationError = Login400 | Login401 | Login403 | Login429;
+/**
+* @summary Sign in with email and password
+*/
+export declare const useLogin: <TError = Login400 | Login401 | Login403 | Login429, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof login>>, TError, {
+        data: LoginBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof login>>, TError, {
+    data: LoginBody;
+}, TContext>;
+/**
+ * @summary Get the current signed-in user
+ */
+export type getCurrentUserResponse200 = {
+    data: GetCurrentUser200;
+    status: 200;
+};
+export type getCurrentUserResponse401 = {
+    data: GetCurrentUser401;
+    status: 401;
+};
+export type getCurrentUserResponseSuccess = (getCurrentUserResponse200) & {
+    headers: Headers;
+};
+export type getCurrentUserResponseError = (getCurrentUserResponse401) & {
+    headers: Headers;
+};
+export type getCurrentUserResponse = (getCurrentUserResponseSuccess | getCurrentUserResponseError);
+export declare const getGetCurrentUserUrl: () => string;
+export declare const getCurrentUser: (options?: RequestInit) => Promise<getCurrentUserResponse>;
+export declare const getGetCurrentUserQueryKey: () => readonly ["/identity/me"];
+export declare const getGetCurrentUserQueryOptions: <TData = Awaited<ReturnType<typeof getCurrentUser>>, TError = GetCurrentUser401>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getCurrentUser>>, TError, TData>>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getCurrentUser>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type GetCurrentUserQueryResult = NonNullable<Awaited<ReturnType<typeof getCurrentUser>>>;
+export type GetCurrentUserQueryError = GetCurrentUser401;
+export declare function useGetCurrentUser<TData = Awaited<ReturnType<typeof getCurrentUser>>, TError = GetCurrentUser401>(options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getCurrentUser>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof getCurrentUser>>, TError, Awaited<ReturnType<typeof getCurrentUser>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetCurrentUser<TData = Awaited<ReturnType<typeof getCurrentUser>>, TError = GetCurrentUser401>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getCurrentUser>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof getCurrentUser>>, TError, Awaited<ReturnType<typeof getCurrentUser>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetCurrentUser<TData = Awaited<ReturnType<typeof getCurrentUser>>, TError = GetCurrentUser401>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getCurrentUser>>, TError, TData>>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * @summary Revoke the current session and clear its cookie
+ */
+export type logoutResponse200 = {
+    data: Logout200;
+    status: 200;
+};
+export type logoutResponse403 = {
+    data: Logout403;
+    status: 403;
+};
+export type logoutResponseSuccess = (logoutResponse200) & {
+    headers: Headers;
+};
+export type logoutResponseError = (logoutResponse403) & {
+    headers: Headers;
+};
+export type logoutResponse = (logoutResponseSuccess | logoutResponseError);
+export declare const getLogoutUrl: () => string;
+export declare const logout: (options?: RequestInit) => Promise<logoutResponse>;
+export declare const getLogoutMutationOptions: <TError = Logout403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof logout>>, TError, void, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof logout>>, TError, void, TContext>;
+export type LogoutMutationResult = NonNullable<Awaited<ReturnType<typeof logout>>>;
+export type LogoutMutationError = Logout403;
+/**
+* @summary Revoke the current session and clear its cookie
+*/
+export declare const useLogout: <TError = Logout403, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof logout>>, TError, void, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof logout>>, TError, void, TContext>;
+/**
+ * Creates the single owner account for the tenant. Use this endpoint only once per deployment.
+ * @summary Create the owner account
+ */
+export type createOwnerResponse201 = {
+    data: CreateOwner201;
+    status: 201;
+};
+export type createOwnerResponse400 = {
+    data: CreateOwner400;
+    status: 400;
+};
+export type createOwnerResponse403 = {
+    data: CreateOwner403;
+    status: 403;
+};
+export type createOwnerResponse409 = {
+    data: CreateOwner409;
+    status: 409;
+};
+export type createOwnerResponse422 = {
+    data: CreateOwner422;
+    status: 422;
+};
+export type createOwnerResponseSuccess = (createOwnerResponse201) & {
+    headers: Headers;
+};
+export type createOwnerResponseError = (createOwnerResponse400 | createOwnerResponse403 | createOwnerResponse409 | createOwnerResponse422) & {
+    headers: Headers;
+};
+export type createOwnerResponse = (createOwnerResponseSuccess | createOwnerResponseError);
+export declare const getCreateOwnerUrl: () => string;
+export declare const createOwner: (createOwnerBody: CreateOwnerBody, options?: RequestInit) => Promise<createOwnerResponse>;
+export declare const getCreateOwnerMutationOptions: <TError = CreateOwner400 | CreateOwner403 | CreateOwner409 | CreateOwner422, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createOwner>>, TError, {
+        data: CreateOwnerBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof createOwner>>, TError, {
+    data: CreateOwnerBody;
+}, TContext>;
+export type CreateOwnerMutationResult = NonNullable<Awaited<ReturnType<typeof createOwner>>>;
+export type CreateOwnerMutationBody = CreateOwnerBody;
+export type CreateOwnerMutationError = CreateOwner400 | CreateOwner403 | CreateOwner409 | CreateOwner422;
+/**
+* @summary Create the owner account
+*/
+export declare const useCreateOwner: <TError = CreateOwner400 | CreateOwner403 | CreateOwner409 | CreateOwner422, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createOwner>>, TError, {
+        data: CreateOwnerBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof createOwner>>, TError, {
+    data: CreateOwnerBody;
+}, TContext>;
+/**
+ * @summary Search addresses by keyword
+ */
+export type searchAddressesResponse200 = {
+    data: SearchAddresses200Item[];
+    status: 200;
+};
+export type searchAddressesResponse400 = {
+    data: SearchAddresses400;
+    status: 400;
+};
+export type searchAddressesResponseSuccess = (searchAddressesResponse200) & {
+    headers: Headers;
+};
+export type searchAddressesResponseError = (searchAddressesResponse400) & {
+    headers: Headers;
+};
+export type searchAddressesResponse = (searchAddressesResponseSuccess | searchAddressesResponseError);
+export declare const getSearchAddressesUrl: (params: SearchAddressesParams) => string;
+export declare const searchAddresses: (params: SearchAddressesParams, options?: RequestInit) => Promise<searchAddressesResponse>;
+export declare const getSearchAddressesQueryKey: (params?: SearchAddressesParams) => readonly ["/addresses/search", ...SearchAddressesParams[]];
+export declare const getSearchAddressesQueryOptions: <TData = Awaited<ReturnType<typeof searchAddresses>>, TError = SearchAddresses400>(params: SearchAddressesParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof searchAddresses>>, TError, TData>>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof searchAddresses>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type SearchAddressesQueryResult = NonNullable<Awaited<ReturnType<typeof searchAddresses>>>;
+export type SearchAddressesQueryError = SearchAddresses400;
+export declare function useSearchAddresses<TData = Awaited<ReturnType<typeof searchAddresses>>, TError = SearchAddresses400>(params: SearchAddressesParams, options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof searchAddresses>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof searchAddresses>>, TError, Awaited<ReturnType<typeof searchAddresses>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useSearchAddresses<TData = Awaited<ReturnType<typeof searchAddresses>>, TError = SearchAddresses400>(params: SearchAddressesParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof searchAddresses>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof searchAddresses>>, TError, Awaited<ReturnType<typeof searchAddresses>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useSearchAddresses<TData = Awaited<ReturnType<typeof searchAddresses>>, TError = SearchAddresses400>(params: SearchAddressesParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof searchAddresses>>, TError, TData>>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * Creates a pending file metadata record and generates a presigned S3 upload URL for direct client-to-storage upload.
+ * @summary Initiate direct file upload to storage
+ */
+export type initiateUploadResponse201 = {
+    data: InitiateUpload201;
+    status: 201;
+};
+export type initiateUploadResponse400 = {
+    data: InitiateUpload400;
+    status: 400;
+};
+export type initiateUploadResponse413 = {
+    data: InitiateUpload413;
+    status: 413;
+};
+export type initiateUploadResponse422 = {
+    data: InitiateUpload422;
+    status: 422;
+};
+export type initiateUploadResponseSuccess = (initiateUploadResponse201) & {
+    headers: Headers;
+};
+export type initiateUploadResponseError = (initiateUploadResponse400 | initiateUploadResponse413 | initiateUploadResponse422) & {
+    headers: Headers;
+};
+export type initiateUploadResponse = (initiateUploadResponseSuccess | initiateUploadResponseError);
+export declare const getInitiateUploadUrl: () => string;
+export declare const initiateUpload: (initiateUploadBody: InitiateUploadBody, options?: RequestInit) => Promise<initiateUploadResponse>;
+export declare const getInitiateUploadMutationOptions: <TError = InitiateUpload400 | InitiateUpload413 | InitiateUpload422, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof initiateUpload>>, TError, {
+        data: InitiateUploadBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof initiateUpload>>, TError, {
+    data: InitiateUploadBody;
+}, TContext>;
+export type InitiateUploadMutationResult = NonNullable<Awaited<ReturnType<typeof initiateUpload>>>;
+export type InitiateUploadMutationBody = InitiateUploadBody;
+export type InitiateUploadMutationError = InitiateUpload400 | InitiateUpload413 | InitiateUpload422;
+/**
+* @summary Initiate direct file upload to storage
+*/
+export declare const useInitiateUpload: <TError = InitiateUpload400 | InitiateUpload413 | InitiateUpload422, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof initiateUpload>>, TError, {
+        data: InitiateUploadBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof initiateUpload>>, TError, {
+    data: InitiateUploadBody;
+}, TContext>;
+/**
+ * Uploads a file directly with base64 encoded content, verifies against purpose policy, stores to S3, and activates immediately.
+ * @summary Direct upload file
+ */
+export type uploadFileResponse201 = {
+    data: UploadFile201;
+    status: 201;
+};
+export type uploadFileResponse400 = {
+    data: UploadFile400;
+    status: 400;
+};
+export type uploadFileResponse413 = {
+    data: UploadFile413;
+    status: 413;
+};
+export type uploadFileResponse422 = {
+    data: UploadFile422;
+    status: 422;
+};
+export type uploadFileResponseSuccess = (uploadFileResponse201) & {
+    headers: Headers;
+};
+export type uploadFileResponseError = (uploadFileResponse400 | uploadFileResponse413 | uploadFileResponse422) & {
+    headers: Headers;
+};
+export type uploadFileResponse = (uploadFileResponseSuccess | uploadFileResponseError);
+export declare const getUploadFileUrl: () => string;
+export declare const uploadFile: (uploadFileBody: UploadFileBody, options?: RequestInit) => Promise<uploadFileResponse>;
+export declare const getUploadFileMutationOptions: <TError = UploadFile400 | UploadFile413 | UploadFile422, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof uploadFile>>, TError, {
+        data: UploadFileBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof uploadFile>>, TError, {
+    data: UploadFileBody;
+}, TContext>;
+export type UploadFileMutationResult = NonNullable<Awaited<ReturnType<typeof uploadFile>>>;
+export type UploadFileMutationBody = UploadFileBody;
+export type UploadFileMutationError = UploadFile400 | UploadFile413 | UploadFile422;
+/**
+* @summary Direct upload file
+*/
+export declare const useUploadFile: <TError = UploadFile400 | UploadFile413 | UploadFile422, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof uploadFile>>, TError, {
+        data: UploadFileBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof uploadFile>>, TError, {
+    data: UploadFileBody;
+}, TContext>;
+/**
+ * Toggles the active state of a warehouse. Soft-deleted warehouses cannot be toggled.
+ * @summary Toggle warehouse active status
+ */
+export type toggleWarehouseStatusResponse200 = {
+    data: ToggleWarehouseStatus200;
+    status: 200;
+};
+export type toggleWarehouseStatusResponse404 = {
+    data: ToggleWarehouseStatus404;
+    status: 404;
+};
+export type toggleWarehouseStatusResponseSuccess = (toggleWarehouseStatusResponse200) & {
+    headers: Headers;
+};
+export type toggleWarehouseStatusResponseError = (toggleWarehouseStatusResponse404) & {
+    headers: Headers;
+};
+export type toggleWarehouseStatusResponse = (toggleWarehouseStatusResponseSuccess | toggleWarehouseStatusResponseError);
+export declare const getToggleWarehouseStatusUrl: (id: string) => string;
+export declare const toggleWarehouseStatus: (id: string, options?: RequestInit) => Promise<toggleWarehouseStatusResponse>;
+export declare const getToggleWarehouseStatusMutationOptions: <TError = ToggleWarehouseStatus404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof toggleWarehouseStatus>>, TError, {
+        id: string;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof toggleWarehouseStatus>>, TError, {
+    id: string;
+}, TContext>;
+export type ToggleWarehouseStatusMutationResult = NonNullable<Awaited<ReturnType<typeof toggleWarehouseStatus>>>;
+export type ToggleWarehouseStatusMutationError = ToggleWarehouseStatus404;
+/**
+* @summary Toggle warehouse active status
+*/
+export declare const useToggleWarehouseStatus: <TError = ToggleWarehouseStatus404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof toggleWarehouseStatus>>, TError, {
+        id: string;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof toggleWarehouseStatus>>, TError, {
+    id: string;
+}, TContext>;
+/**
+ * Activates or deactivates a stock item.
+ * @summary Change stock item active status
+ */
+export type changeStockItemStatusResponse200 = {
+    data: ChangeStockItemStatus200;
+    status: 200;
+};
+export type changeStockItemStatusResponse400 = {
+    data: ChangeStockItemStatus400;
+    status: 400;
+};
+export type changeStockItemStatusResponse404 = {
+    data: ChangeStockItemStatus404;
+    status: 404;
+};
+export type changeStockItemStatusResponseSuccess = (changeStockItemStatusResponse200) & {
+    headers: Headers;
+};
+export type changeStockItemStatusResponseError = (changeStockItemStatusResponse400 | changeStockItemStatusResponse404) & {
+    headers: Headers;
+};
+export type changeStockItemStatusResponse = (changeStockItemStatusResponseSuccess | changeStockItemStatusResponseError);
+export declare const getChangeStockItemStatusUrl: (id: string) => string;
+export declare const changeStockItemStatus: (id: string, changeStockItemStatusBody: ChangeStockItemStatusBody, options?: RequestInit) => Promise<changeStockItemStatusResponse>;
+export declare const getChangeStockItemStatusMutationOptions: <TError = ChangeStockItemStatus400 | ChangeStockItemStatus404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof changeStockItemStatus>>, TError, {
+        id: string;
+        data: ChangeStockItemStatusBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof changeStockItemStatus>>, TError, {
+    id: string;
+    data: ChangeStockItemStatusBody;
+}, TContext>;
+export type ChangeStockItemStatusMutationResult = NonNullable<Awaited<ReturnType<typeof changeStockItemStatus>>>;
+export type ChangeStockItemStatusMutationBody = ChangeStockItemStatusBody;
+export type ChangeStockItemStatusMutationError = ChangeStockItemStatus400 | ChangeStockItemStatus404;
+/**
+* @summary Change stock item active status
+*/
+export declare const useChangeStockItemStatus: <TError = ChangeStockItemStatus400 | ChangeStockItemStatus404, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof changeStockItemStatus>>, TError, {
+        id: string;
+        data: ChangeStockItemStatusBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof changeStockItemStatus>>, TError, {
+    id: string;
+    data: ChangeStockItemStatusBody;
+}, TContext>;
+/**
+ * Verifies that physical object was written to storage provider, verifies checksum, and transitions file to ACTIVE.
+ * @summary Complete direct file upload
+ */
+export type completeUploadResponse200 = {
+    data: CompleteUpload200;
+    status: 200;
+};
+export type completeUploadResponse400 = {
+    data: CompleteUpload400;
+    status: 400;
+};
+export type completeUploadResponse404 = {
+    data: CompleteUpload404;
+    status: 404;
+};
+export type completeUploadResponse422 = {
+    data: CompleteUpload422;
+    status: 422;
+};
+export type completeUploadResponse500 = {
+    data: CompleteUpload500;
+    status: 500;
+};
+export type completeUploadResponseSuccess = (completeUploadResponse200) & {
+    headers: Headers;
+};
+export type completeUploadResponseError = (completeUploadResponse400 | completeUploadResponse404 | completeUploadResponse422 | completeUploadResponse500) & {
+    headers: Headers;
+};
+export type completeUploadResponse = (completeUploadResponseSuccess | completeUploadResponseError);
+export declare const getCompleteUploadUrl: (id: string) => string;
+export declare const completeUpload: (id: string, completeUploadBody: CompleteUploadBody, options?: RequestInit) => Promise<completeUploadResponse>;
+export declare const getCompleteUploadMutationOptions: <TError = CompleteUpload400 | CompleteUpload404 | CompleteUpload422 | CompleteUpload500, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof completeUpload>>, TError, {
+        id: string;
+        data: CompleteUploadBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof completeUpload>>, TError, {
+    id: string;
+    data: CompleteUploadBody;
+}, TContext>;
+export type CompleteUploadMutationResult = NonNullable<Awaited<ReturnType<typeof completeUpload>>>;
+export type CompleteUploadMutationBody = CompleteUploadBody;
+export type CompleteUploadMutationError = CompleteUpload400 | CompleteUpload404 | CompleteUpload422 | CompleteUpload500;
+/**
+* @summary Complete direct file upload
+*/
+export declare const useCompleteUpload: <TError = CompleteUpload400 | CompleteUpload404 | CompleteUpload422 | CompleteUpload500, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof completeUpload>>, TError, {
+        id: string;
+        data: CompleteUploadBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof completeUpload>>, TError, {
+    id: string;
+    data: CompleteUploadBody;
+}, TContext>;
+/**
+ * Generates a public CDN URL (for public files) or a time-limited signed download URL (for private files).
+ * @summary Get file download or CDN access URL
+ */
+export type getFileAccessUrlResponse200 = {
+    data: GetFileAccessUrl200;
+    status: 200;
+};
+export type getFileAccessUrlResponse400 = {
+    data: GetFileAccessUrl400;
+    status: 400;
+};
+export type getFileAccessUrlResponse404 = {
+    data: GetFileAccessUrl404;
+    status: 404;
+};
+export type getFileAccessUrlResponse422 = {
+    data: GetFileAccessUrl422;
+    status: 422;
+};
+export type getFileAccessUrlResponseSuccess = (getFileAccessUrlResponse200) & {
+    headers: Headers;
+};
+export type getFileAccessUrlResponseError = (getFileAccessUrlResponse400 | getFileAccessUrlResponse404 | getFileAccessUrlResponse422) & {
+    headers: Headers;
+};
+export type getFileAccessUrlResponse = (getFileAccessUrlResponseSuccess | getFileAccessUrlResponseError);
+export declare const getGetFileAccessUrlUrl: (id: string, params?: GetFileAccessUrlParams) => string;
+export declare const getFileAccessUrl: (id: string, params?: GetFileAccessUrlParams, options?: RequestInit) => Promise<getFileAccessUrlResponse>;
+export declare const getGetFileAccessUrlQueryKey: (id?: string, params?: GetFileAccessUrlParams) => readonly [`/files/${string}/access-url`, ...GetFileAccessUrlParams[]];
+export declare const getGetFileAccessUrlQueryOptions: <TData = Awaited<ReturnType<typeof getFileAccessUrl>>, TError = GetFileAccessUrl400 | GetFileAccessUrl404 | GetFileAccessUrl422>(id: string, params?: GetFileAccessUrlParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getFileAccessUrl>>, TError, TData>>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getFileAccessUrl>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type GetFileAccessUrlQueryResult = NonNullable<Awaited<ReturnType<typeof getFileAccessUrl>>>;
+export type GetFileAccessUrlQueryError = GetFileAccessUrl400 | GetFileAccessUrl404 | GetFileAccessUrl422;
+export declare function useGetFileAccessUrl<TData = Awaited<ReturnType<typeof getFileAccessUrl>>, TError = GetFileAccessUrl400 | GetFileAccessUrl404 | GetFileAccessUrl422>(id: string, params: undefined | GetFileAccessUrlParams, options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getFileAccessUrl>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof getFileAccessUrl>>, TError, Awaited<ReturnType<typeof getFileAccessUrl>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetFileAccessUrl<TData = Awaited<ReturnType<typeof getFileAccessUrl>>, TError = GetFileAccessUrl400 | GetFileAccessUrl404 | GetFileAccessUrl422>(id: string, params?: GetFileAccessUrlParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getFileAccessUrl>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof getFileAccessUrl>>, TError, Awaited<ReturnType<typeof getFileAccessUrl>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetFileAccessUrl<TData = Awaited<ReturnType<typeof getFileAccessUrl>>, TError = GetFileAccessUrl400 | GetFileAccessUrl404 | GetFileAccessUrl422>(id: string, params?: GetFileAccessUrlParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getFileAccessUrl>>, TError, TData>>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * Retrieves warehouse details by its identifier. Returns 404 if not found or soft-deleted.
+ * @summary Get warehouse by ID
+ */
+export type getWarehouseByIdResponse200 = {
+    data: GetWarehouseById200;
+    status: 200;
+};
+export type getWarehouseByIdResponse404 = {
+    data: GetWarehouseById404;
+    status: 404;
+};
+export type getWarehouseByIdResponseSuccess = (getWarehouseByIdResponse200) & {
+    headers: Headers;
+};
+export type getWarehouseByIdResponseError = (getWarehouseByIdResponse404) & {
+    headers: Headers;
+};
+export type getWarehouseByIdResponse = (getWarehouseByIdResponseSuccess | getWarehouseByIdResponseError);
+export declare const getGetWarehouseByIdUrl: (id: string) => string;
+export declare const getWarehouseById: (id: string, options?: RequestInit) => Promise<getWarehouseByIdResponse>;
+export declare const getGetWarehouseByIdQueryKey: (id?: string) => readonly [`/warehouses/${string}`];
+export declare const getGetWarehouseByIdQueryOptions: <TData = Awaited<ReturnType<typeof getWarehouseById>>, TError = GetWarehouseById404>(id: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getWarehouseById>>, TError, TData>>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getWarehouseById>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type GetWarehouseByIdQueryResult = NonNullable<Awaited<ReturnType<typeof getWarehouseById>>>;
+export type GetWarehouseByIdQueryError = GetWarehouseById404;
+export declare function useGetWarehouseById<TData = Awaited<ReturnType<typeof getWarehouseById>>, TError = GetWarehouseById404>(id: string, options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getWarehouseById>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof getWarehouseById>>, TError, Awaited<ReturnType<typeof getWarehouseById>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetWarehouseById<TData = Awaited<ReturnType<typeof getWarehouseById>>, TError = GetWarehouseById404>(id: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getWarehouseById>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof getWarehouseById>>, TError, Awaited<ReturnType<typeof getWarehouseById>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetWarehouseById<TData = Awaited<ReturnType<typeof getWarehouseById>>, TError = GetWarehouseById404>(id: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getWarehouseById>>, TError, TData>>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * Updates warehouse name, person in charge, and address. Increments version on update.
+ * @summary Update warehouse
+ */
+export type updateWarehouseResponse400 = {
+    data: UpdateWarehouse400;
+    status: 400;
+};
+export type updateWarehouseResponse404 = {
+    data: UpdateWarehouse404;
+    status: 404;
+};
+export type updateWarehouseResponse409 = {
+    data: UpdateWarehouse409;
+    status: 409;
+};
+export type updateWarehouseResponse422 = {
+    data: UpdateWarehouse422;
+    status: 422;
+};
+export type updateWarehouseResponseError = (updateWarehouseResponse400 | updateWarehouseResponse404 | updateWarehouseResponse409 | updateWarehouseResponse422) & {
+    headers: Headers;
+};
+export type updateWarehouseResponse = (updateWarehouseResponseError);
+export declare const getUpdateWarehouseUrl: (id: string) => string;
+export declare const updateWarehouse: (id: string, updateWarehouseBody: UpdateWarehouseBody, options?: RequestInit) => Promise<updateWarehouseResponse>;
+export declare const getUpdateWarehouseMutationOptions: <TError = UpdateWarehouse400 | UpdateWarehouse404 | UpdateWarehouse409 | UpdateWarehouse422, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof updateWarehouse>>, TError, {
+        id: string;
+        data: UpdateWarehouseBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof updateWarehouse>>, TError, {
+    id: string;
+    data: UpdateWarehouseBody;
+}, TContext>;
+export type UpdateWarehouseMutationResult = NonNullable<Awaited<ReturnType<typeof updateWarehouse>>>;
+export type UpdateWarehouseMutationBody = UpdateWarehouseBody;
+export type UpdateWarehouseMutationError = UpdateWarehouse400 | UpdateWarehouse404 | UpdateWarehouse409 | UpdateWarehouse422;
+/**
+* @summary Update warehouse
+*/
+export declare const useUpdateWarehouse: <TError = UpdateWarehouse400 | UpdateWarehouse404 | UpdateWarehouse409 | UpdateWarehouse422, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof updateWarehouse>>, TError, {
+        id: string;
+        data: UpdateWarehouseBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof updateWarehouse>>, TError, {
+    id: string;
+    data: UpdateWarehouseBody;
+}, TContext>;
+/**
+ * Soft-deletes a warehouse by setting its deletedAt timestamp. Cannot delete active warehouses.
+ * @summary Delete warehouse
+ */
+export type deleteWarehouseResponse400 = {
+    data: DeleteWarehouse400;
+    status: 400;
+};
+export type deleteWarehouseResponse404 = {
+    data: DeleteWarehouse404;
+    status: 404;
+};
+export type deleteWarehouseResponse409 = {
+    data: DeleteWarehouse409;
+    status: 409;
+};
+export type deleteWarehouseResponseError = (deleteWarehouseResponse400 | deleteWarehouseResponse404 | deleteWarehouseResponse409) & {
+    headers: Headers;
+};
+export type deleteWarehouseResponse = (deleteWarehouseResponseError);
+export declare const getDeleteWarehouseUrl: (id: string) => string;
+export declare const deleteWarehouse: (id: string, options?: RequestInit) => Promise<deleteWarehouseResponse>;
+export declare const getDeleteWarehouseMutationOptions: <TError = DeleteWarehouse400 | DeleteWarehouse404 | DeleteWarehouse409, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof deleteWarehouse>>, TError, {
+        id: string;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof deleteWarehouse>>, TError, {
+    id: string;
+}, TContext>;
+export type DeleteWarehouseMutationResult = NonNullable<Awaited<ReturnType<typeof deleteWarehouse>>>;
+export type DeleteWarehouseMutationError = DeleteWarehouse400 | DeleteWarehouse404 | DeleteWarehouse409;
+/**
+* @summary Delete warehouse
+*/
+export declare const useDeleteWarehouse: <TError = DeleteWarehouse400 | DeleteWarehouse404 | DeleteWarehouse409, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof deleteWarehouse>>, TError, {
+        id: string;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof deleteWarehouse>>, TError, {
+    id: string;
+}, TContext>;
+/**
+ * Updates a stock item name, SKU, or image. Increments version on update.
+ * @summary Update stock item
+ */
+export type updateStockItemResponse400 = {
+    data: UpdateStockItem400;
+    status: 400;
+};
+export type updateStockItemResponse404 = {
+    data: UpdateStockItem404;
+    status: 404;
+};
+export type updateStockItemResponse409 = {
+    data: UpdateStockItem409;
+    status: 409;
+};
+export type updateStockItemResponseError = (updateStockItemResponse400 | updateStockItemResponse404 | updateStockItemResponse409) & {
+    headers: Headers;
+};
+export type updateStockItemResponse = (updateStockItemResponseError);
+export declare const getUpdateStockItemUrl: (id: string) => string;
+export declare const updateStockItem: (id: string, updateStockItemBody: UpdateStockItemBody, options?: RequestInit) => Promise<updateStockItemResponse>;
+export declare const getUpdateStockItemMutationOptions: <TError = UpdateStockItem400 | UpdateStockItem404 | UpdateStockItem409, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof updateStockItem>>, TError, {
+        id: string;
+        data: UpdateStockItemBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof updateStockItem>>, TError, {
+    id: string;
+    data: UpdateStockItemBody;
+}, TContext>;
+export type UpdateStockItemMutationResult = NonNullable<Awaited<ReturnType<typeof updateStockItem>>>;
+export type UpdateStockItemMutationBody = UpdateStockItemBody;
+export type UpdateStockItemMutationError = UpdateStockItem400 | UpdateStockItem404 | UpdateStockItem409;
+/**
+* @summary Update stock item
+*/
+export declare const useUpdateStockItem: <TError = UpdateStockItem400 | UpdateStockItem404 | UpdateStockItem409, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof updateStockItem>>, TError, {
+        id: string;
+        data: UpdateStockItemBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof updateStockItem>>, TError, {
+    id: string;
+    data: UpdateStockItemBody;
+}, TContext>;
+/**
+ * Soft-deletes a stock item by setting its deletedAt timestamp. Cannot delete active stock items.
+ * @summary Delete stock item
+ */
+export type deleteStockItemResponse400 = {
+    data: DeleteStockItem400;
+    status: 400;
+};
+export type deleteStockItemResponse404 = {
+    data: DeleteStockItem404;
+    status: 404;
+};
+export type deleteStockItemResponse409 = {
+    data: DeleteStockItem409;
+    status: 409;
+};
+export type deleteStockItemResponseError = (deleteStockItemResponse400 | deleteStockItemResponse404 | deleteStockItemResponse409) & {
+    headers: Headers;
+};
+export type deleteStockItemResponse = (deleteStockItemResponseError);
+export declare const getDeleteStockItemUrl: (id: string) => string;
+export declare const deleteStockItem: (id: string, options?: RequestInit) => Promise<deleteStockItemResponse>;
+export declare const getDeleteStockItemMutationOptions: <TError = DeleteStockItem400 | DeleteStockItem404 | DeleteStockItem409, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof deleteStockItem>>, TError, {
+        id: string;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof deleteStockItem>>, TError, {
+    id: string;
+}, TContext>;
+export type DeleteStockItemMutationResult = NonNullable<Awaited<ReturnType<typeof deleteStockItem>>>;
+export type DeleteStockItemMutationError = DeleteStockItem400 | DeleteStockItem404 | DeleteStockItem409;
+/**
+* @summary Delete stock item
+*/
+export declare const useDeleteStockItem: <TError = DeleteStockItem400 | DeleteStockItem404 | DeleteStockItem409, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof deleteStockItem>>, TError, {
+        id: string;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof deleteStockItem>>, TError, {
+    id: string;
+}, TContext>;
+/**
+ * Retrieves active stored file metadata by its ID.
+ * @summary Get stored file by ID
+ */
+export type getStoredFileByIdResponse200 = {
+    data: GetStoredFileById200;
+    status: 200;
+};
+export type getStoredFileByIdResponse400 = {
+    data: GetStoredFileById400;
+    status: 400;
+};
+export type getStoredFileByIdResponse404 = {
+    data: GetStoredFileById404;
+    status: 404;
+};
+export type getStoredFileByIdResponseSuccess = (getStoredFileByIdResponse200) & {
+    headers: Headers;
+};
+export type getStoredFileByIdResponseError = (getStoredFileByIdResponse400 | getStoredFileByIdResponse404) & {
+    headers: Headers;
+};
+export type getStoredFileByIdResponse = (getStoredFileByIdResponseSuccess | getStoredFileByIdResponseError);
+export declare const getGetStoredFileByIdUrl: (id: string) => string;
+export declare const getStoredFileById: (id: string, options?: RequestInit) => Promise<getStoredFileByIdResponse>;
+export declare const getGetStoredFileByIdQueryKey: (id?: string) => readonly [`/files/${string}`];
+export declare const getGetStoredFileByIdQueryOptions: <TData = Awaited<ReturnType<typeof getStoredFileById>>, TError = GetStoredFileById400 | GetStoredFileById404>(id: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getStoredFileById>>, TError, TData>>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getStoredFileById>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type GetStoredFileByIdQueryResult = NonNullable<Awaited<ReturnType<typeof getStoredFileById>>>;
+export type GetStoredFileByIdQueryError = GetStoredFileById400 | GetStoredFileById404;
+export declare function useGetStoredFileById<TData = Awaited<ReturnType<typeof getStoredFileById>>, TError = GetStoredFileById400 | GetStoredFileById404>(id: string, options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getStoredFileById>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof getStoredFileById>>, TError, Awaited<ReturnType<typeof getStoredFileById>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetStoredFileById<TData = Awaited<ReturnType<typeof getStoredFileById>>, TError = GetStoredFileById400 | GetStoredFileById404>(id: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getStoredFileById>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof getStoredFileById>>, TError, Awaited<ReturnType<typeof getStoredFileById>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetStoredFileById<TData = Awaited<ReturnType<typeof getStoredFileById>>, TError = GetStoredFileById400 | GetStoredFileById404>(id: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getStoredFileById>>, TError, TData>>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * Marks a stored file as DELETED. Files in active use by other modules cannot be deleted.
+ * @summary Soft delete stored file
+ */
+export type deleteStoredFileResponse400 = {
+    data: DeleteStoredFile400;
+    status: 400;
+};
+export type deleteStoredFileResponse404 = {
+    data: DeleteStoredFile404;
+    status: 404;
+};
+export type deleteStoredFileResponse409 = {
+    data: DeleteStoredFile409;
+    status: 409;
+};
+export type deleteStoredFileResponseError = (deleteStoredFileResponse400 | deleteStoredFileResponse404 | deleteStoredFileResponse409) & {
+    headers: Headers;
+};
+export type deleteStoredFileResponse = (deleteStoredFileResponseError);
+export declare const getDeleteStoredFileUrl: (id: string) => string;
+export declare const deleteStoredFile: (id: string, options?: RequestInit) => Promise<deleteStoredFileResponse>;
+export declare const getDeleteStoredFileMutationOptions: <TError = DeleteStoredFile400 | DeleteStoredFile404 | DeleteStoredFile409, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof deleteStoredFile>>, TError, {
+        id: string;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof deleteStoredFile>>, TError, {
+    id: string;
+}, TContext>;
+export type DeleteStoredFileMutationResult = NonNullable<Awaited<ReturnType<typeof deleteStoredFile>>>;
+export type DeleteStoredFileMutationError = DeleteStoredFile400 | DeleteStoredFile404 | DeleteStoredFile409;
+/**
+* @summary Soft delete stored file
+*/
+export declare const useDeleteStoredFile: <TError = DeleteStoredFile400 | DeleteStoredFile404 | DeleteStoredFile409, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof deleteStoredFile>>, TError, {
+        id: string;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof deleteStoredFile>>, TError, {
+    id: string;
+}, TContext>;
+/**
+ * @summary Health check
+ */
+export type getHealthResponse200 = {
+    data: GetHealth200;
+    status: 200;
+};
+export type getHealthResponse503 = {
+    data: GetHealth503;
+    status: 503;
+};
+export type getHealthResponseSuccess = (getHealthResponse200) & {
+    headers: Headers;
+};
+export type getHealthResponseError = (getHealthResponse503) & {
+    headers: Headers;
+};
+export type getHealthResponse = (getHealthResponseSuccess | getHealthResponseError);
+export declare const getGetHealthUrl: () => string;
+export declare const getHealth: (options?: RequestInit) => Promise<getHealthResponse>;
+export declare const getGetHealthQueryKey: () => readonly ["/health"];
+export declare const getGetHealthQueryOptions: <TData = Awaited<ReturnType<typeof getHealth>>, TError = GetHealth503>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getHealth>>, TError, TData>>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getHealth>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type GetHealthQueryResult = NonNullable<Awaited<ReturnType<typeof getHealth>>>;
+export type GetHealthQueryError = GetHealth503;
+export declare function useGetHealth<TData = Awaited<ReturnType<typeof getHealth>>, TError = GetHealth503>(options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getHealth>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof getHealth>>, TError, Awaited<ReturnType<typeof getHealth>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetHealth<TData = Awaited<ReturnType<typeof getHealth>>, TError = GetHealth503>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getHealth>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof getHealth>>, TError, Awaited<ReturnType<typeof getHealth>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetHealth<TData = Awaited<ReturnType<typeof getHealth>>, TError = GetHealth503>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getHealth>>, TError, TData>>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type getCustomersResponse200 = {
+    data: void;
+    status: 200;
+};
+export type getCustomersResponseSuccess = (getCustomersResponse200) & {
+    headers: Headers;
+};
+export type getCustomersResponse = (getCustomersResponseSuccess);
+export declare const getGetCustomersUrl: () => string;
+export declare const getCustomers: (options?: RequestInit) => Promise<getCustomersResponse>;
+export declare const getGetCustomersQueryKey: () => readonly ["/customers"];
+export declare const getGetCustomersQueryOptions: <TData = Awaited<ReturnType<typeof getCustomers>>, TError = unknown>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getCustomers>>, TError, TData>>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof getCustomers>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type GetCustomersQueryResult = NonNullable<Awaited<ReturnType<typeof getCustomers>>>;
+export type GetCustomersQueryError = unknown;
+export declare function useGetCustomers<TData = Awaited<ReturnType<typeof getCustomers>>, TError = unknown>(options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getCustomers>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof getCustomers>>, TError, Awaited<ReturnType<typeof getCustomers>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetCustomers<TData = Awaited<ReturnType<typeof getCustomers>>, TError = unknown>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getCustomers>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof getCustomers>>, TError, Awaited<ReturnType<typeof getCustomers>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGetCustomers<TData = Awaited<ReturnType<typeof getCustomers>>, TError = unknown>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getCustomers>>, TError, TData>>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * Creates a new warehouse with an address resolved from the Address service and an initial active state.
+ * @summary Create a new warehouse
+ */
+export type createWarehouseResponse201 = {
+    data: CreateWarehouse201;
+    status: 201;
+};
+export type createWarehouseResponse400 = {
+    data: CreateWarehouse400;
+    status: 400;
+};
+export type createWarehouseResponse404 = {
+    data: CreateWarehouse404;
+    status: 404;
+};
+export type createWarehouseResponse409 = {
+    data: CreateWarehouse409;
+    status: 409;
+};
+export type createWarehouseResponse422 = {
+    data: CreateWarehouse422;
+    status: 422;
+};
+export type createWarehouseResponseSuccess = (createWarehouseResponse201) & {
+    headers: Headers;
+};
+export type createWarehouseResponseError = (createWarehouseResponse400 | createWarehouseResponse404 | createWarehouseResponse409 | createWarehouseResponse422) & {
+    headers: Headers;
+};
+export type createWarehouseResponse = (createWarehouseResponseSuccess | createWarehouseResponseError);
+export declare const getCreateWarehouseUrl: () => string;
+export declare const createWarehouse: (createWarehouseBody: CreateWarehouseBody, options?: RequestInit) => Promise<createWarehouseResponse>;
+export declare const getCreateWarehouseMutationOptions: <TError = CreateWarehouse400 | CreateWarehouse404 | CreateWarehouse409 | CreateWarehouse422, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createWarehouse>>, TError, {
+        data: CreateWarehouseBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof createWarehouse>>, TError, {
+    data: CreateWarehouseBody;
+}, TContext>;
+export type CreateWarehouseMutationResult = NonNullable<Awaited<ReturnType<typeof createWarehouse>>>;
+export type CreateWarehouseMutationBody = CreateWarehouseBody;
+export type CreateWarehouseMutationError = CreateWarehouse400 | CreateWarehouse404 | CreateWarehouse409 | CreateWarehouse422;
+/**
+* @summary Create a new warehouse
+*/
+export declare const useCreateWarehouse: <TError = CreateWarehouse400 | CreateWarehouse404 | CreateWarehouse409 | CreateWarehouse422, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createWarehouse>>, TError, {
+        data: CreateWarehouseBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof createWarehouse>>, TError, {
+    data: CreateWarehouseBody;
+}, TContext>;
+/**
+ * Retrieves a filtered list of warehouses. Excludes soft-deleted warehouses.
+ * @summary List all warehouses
+ */
+export type listWarehousesResponse200 = {
+    data: ListWarehouses200;
+    status: 200;
+};
+export type listWarehousesResponseSuccess = (listWarehousesResponse200) & {
+    headers: Headers;
+};
+export type listWarehousesResponse = (listWarehousesResponseSuccess);
+export declare const getListWarehousesUrl: (params?: ListWarehousesParams) => string;
+export declare const listWarehouses: (params?: ListWarehousesParams, options?: RequestInit) => Promise<listWarehousesResponse>;
+export declare const getListWarehousesQueryKey: (params?: ListWarehousesParams) => readonly ["/warehouses", ...ListWarehousesParams[]];
+export declare const getListWarehousesQueryOptions: <TData = Awaited<ReturnType<typeof listWarehouses>>, TError = unknown>(params?: ListWarehousesParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listWarehouses>>, TError, TData>>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof listWarehouses>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ListWarehousesQueryResult = NonNullable<Awaited<ReturnType<typeof listWarehouses>>>;
+export type ListWarehousesQueryError = unknown;
+export declare function useListWarehouses<TData = Awaited<ReturnType<typeof listWarehouses>>, TError = unknown>(params: undefined | ListWarehousesParams, options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof listWarehouses>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof listWarehouses>>, TError, Awaited<ReturnType<typeof listWarehouses>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListWarehouses<TData = Awaited<ReturnType<typeof listWarehouses>>, TError = unknown>(params?: ListWarehousesParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listWarehouses>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof listWarehouses>>, TError, Awaited<ReturnType<typeof listWarehouses>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListWarehouses<TData = Awaited<ReturnType<typeof listWarehouses>>, TError = unknown>(params?: ListWarehousesParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listWarehouses>>, TError, TData>>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * Lists paginated stock movements with optional filtering by itemId, batchId, warehouseId, and sorting.
+ * @summary List stock movements
+ */
+export type listStockMovementsResponse200 = {
+    data: ListStockMovements200;
+    status: 200;
+};
+export type listStockMovementsResponseSuccess = (listStockMovementsResponse200) & {
+    headers: Headers;
+};
+export type listStockMovementsResponse = (listStockMovementsResponseSuccess);
+export declare const getListStockMovementsUrl: (params?: ListStockMovementsParams) => string;
+export declare const listStockMovements: (params?: ListStockMovementsParams, options?: RequestInit) => Promise<listStockMovementsResponse>;
+export declare const getListStockMovementsQueryKey: (params?: ListStockMovementsParams) => readonly ["/stock-movements", ...ListStockMovementsParams[]];
+export declare const getListStockMovementsQueryOptions: <TData = Awaited<ReturnType<typeof listStockMovements>>, TError = unknown>(params?: ListStockMovementsParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listStockMovements>>, TError, TData>>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof listStockMovements>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ListStockMovementsQueryResult = NonNullable<Awaited<ReturnType<typeof listStockMovements>>>;
+export type ListStockMovementsQueryError = unknown;
+export declare function useListStockMovements<TData = Awaited<ReturnType<typeof listStockMovements>>, TError = unknown>(params: undefined | ListStockMovementsParams, options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof listStockMovements>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof listStockMovements>>, TError, Awaited<ReturnType<typeof listStockMovements>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListStockMovements<TData = Awaited<ReturnType<typeof listStockMovements>>, TError = unknown>(params?: ListStockMovementsParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listStockMovements>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof listStockMovements>>, TError, Awaited<ReturnType<typeof listStockMovements>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListStockMovements<TData = Awaited<ReturnType<typeof listStockMovements>>, TError = unknown>(params?: ListStockMovementsParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listStockMovements>>, TError, TData>>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * Creates a new stock item with a unique SKU and name.
+ * @summary Create a new stock item
+ */
+export type createStockItemResponse201 = {
+    data: CreateStockItem201;
+    status: 201;
+};
+export type createStockItemResponse400 = {
+    data: CreateStockItem400;
+    status: 400;
+};
+export type createStockItemResponse409 = {
+    data: CreateStockItem409;
+    status: 409;
+};
+export type createStockItemResponseSuccess = (createStockItemResponse201) & {
+    headers: Headers;
+};
+export type createStockItemResponseError = (createStockItemResponse400 | createStockItemResponse409) & {
+    headers: Headers;
+};
+export type createStockItemResponse = (createStockItemResponseSuccess | createStockItemResponseError);
+export declare const getCreateStockItemUrl: () => string;
+export declare const createStockItem: (createStockItemBody: CreateStockItemBody, options?: RequestInit) => Promise<createStockItemResponse>;
+export declare const getCreateStockItemMutationOptions: <TError = CreateStockItem400 | CreateStockItem409, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createStockItem>>, TError, {
+        data: CreateStockItemBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof createStockItem>>, TError, {
+    data: CreateStockItemBody;
+}, TContext>;
+export type CreateStockItemMutationResult = NonNullable<Awaited<ReturnType<typeof createStockItem>>>;
+export type CreateStockItemMutationBody = CreateStockItemBody;
+export type CreateStockItemMutationError = CreateStockItem400 | CreateStockItem409;
+/**
+* @summary Create a new stock item
+*/
+export declare const useCreateStockItem: <TError = CreateStockItem400 | CreateStockItem409, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createStockItem>>, TError, {
+        data: CreateStockItemBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof createStockItem>>, TError, {
+    data: CreateStockItemBody;
+}, TContext>;
+/**
+ * Lists paginated stock items with aggregate on-hand, reserved, and available stock levels. Optionally filters by warehouseId, search, and isActive status.
+ * @summary List stock items
+ */
+export type listStockItemsResponse200 = {
+    data: ListStockItems200;
+    status: 200;
+};
+export type listStockItemsResponseSuccess = (listStockItemsResponse200) & {
+    headers: Headers;
+};
+export type listStockItemsResponse = (listStockItemsResponseSuccess);
+export declare const getListStockItemsUrl: (params?: ListStockItemsParams) => string;
+export declare const listStockItems: (params?: ListStockItemsParams, options?: RequestInit) => Promise<listStockItemsResponse>;
+export declare const getListStockItemsQueryKey: (params?: ListStockItemsParams) => readonly ["/stock-items", ...ListStockItemsParams[]];
+export declare const getListStockItemsQueryOptions: <TData = Awaited<ReturnType<typeof listStockItems>>, TError = unknown>(params?: ListStockItemsParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listStockItems>>, TError, TData>>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof listStockItems>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type ListStockItemsQueryResult = NonNullable<Awaited<ReturnType<typeof listStockItems>>>;
+export type ListStockItemsQueryError = unknown;
+export declare function useListStockItems<TData = Awaited<ReturnType<typeof listStockItems>>, TError = unknown>(params: undefined | ListStockItemsParams, options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof listStockItems>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof listStockItems>>, TError, Awaited<ReturnType<typeof listStockItems>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListStockItems<TData = Awaited<ReturnType<typeof listStockItems>>, TError = unknown>(params?: ListStockItemsParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listStockItems>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof listStockItems>>, TError, Awaited<ReturnType<typeof listStockItems>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useListStockItems<TData = Awaited<ReturnType<typeof listStockItems>>, TError = unknown>(params?: ListStockItemsParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listStockItems>>, TError, TData>>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+/**
+ * Records a new batch receipt into a warehouse and updates stock levels atomically.
+ * @summary Create a new stock batch
+ */
+export type createBatchResponse201 = {
+    data: CreateBatch201;
+    status: 201;
+};
+export type createBatchResponse400 = {
+    data: CreateBatch400;
+    status: 400;
+};
+export type createBatchResponse404 = {
+    data: CreateBatch404;
+    status: 404;
+};
+export type createBatchResponse409 = {
+    data: CreateBatch409;
+    status: 409;
+};
+export type createBatchResponseSuccess = (createBatchResponse201) & {
+    headers: Headers;
+};
+export type createBatchResponseError = (createBatchResponse400 | createBatchResponse404 | createBatchResponse409) & {
+    headers: Headers;
+};
+export type createBatchResponse = (createBatchResponseSuccess | createBatchResponseError);
+export declare const getCreateBatchUrl: () => string;
+export declare const createBatch: (createBatchBody: CreateBatchBody, options?: RequestInit) => Promise<createBatchResponse>;
+export declare const getCreateBatchMutationOptions: <TError = CreateBatch400 | CreateBatch404 | CreateBatch409, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createBatch>>, TError, {
+        data: CreateBatchBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof createBatch>>, TError, {
+    data: CreateBatchBody;
+}, TContext>;
+export type CreateBatchMutationResult = NonNullable<Awaited<ReturnType<typeof createBatch>>>;
+export type CreateBatchMutationBody = CreateBatchBody;
+export type CreateBatchMutationError = CreateBatch400 | CreateBatch404 | CreateBatch409;
+/**
+* @summary Create a new stock batch
+*/
+export declare const useCreateBatch: <TError = CreateBatch400 | CreateBatch404 | CreateBatch409, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof createBatch>>, TError, {
+        data: CreateBatchBody;
+    }, TContext>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient) => UseMutationResult<Awaited<ReturnType<typeof createBatch>>, TError, {
+    data: CreateBatchBody;
+}, TContext>;
+/**
+ * @summary API welcome message
+ */
+export type getResponse200 = {
+    data: Get200;
+    status: 200;
+};
+export type getResponse503 = {
+    data: Get503;
+    status: 503;
+};
+export type getResponseSuccess = (getResponse200) & {
+    headers: Headers;
+};
+export type getResponseError = (getResponse503) & {
+    headers: Headers;
+};
+export type getResponse = (getResponseSuccess | getResponseError);
+export declare const getGetUrl: () => string;
+export declare const get: (options?: RequestInit) => Promise<getResponse>;
+export declare const getGetQueryKey: () => readonly ["/"];
+export declare const getGetQueryOptions: <TData = Awaited<ReturnType<typeof get>>, TError = Get503>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof get>>, TError, TData>>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof get>>, TError, TData> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export type GetQueryResult = NonNullable<Awaited<ReturnType<typeof get>>>;
+export type GetQueryError = Get503;
+export declare function useGet<TData = Awaited<ReturnType<typeof get>>, TError = Get503>(options: {
+    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof get>>, TError, TData>> & Pick<DefinedInitialDataOptions<Awaited<ReturnType<typeof get>>, TError, Awaited<ReturnType<typeof get>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): DefinedUseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGet<TData = Awaited<ReturnType<typeof get>>, TError = Get503>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof get>>, TError, TData>> & Pick<UndefinedInitialDataOptions<Awaited<ReturnType<typeof get>>, TError, Awaited<ReturnType<typeof get>>>, 'initialData'>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+export declare function useGet<TData = Awaited<ReturnType<typeof get>>, TError = Get503>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof get>>, TError, TData>>;
+    fetch?: RequestInit;
+}, queryClient?: QueryClient): UseQueryResult<TData, TError> & {
+    queryKey: DataTag<QueryKey, TData, TError>;
+};
+//# sourceMappingURL=api.d.ts.map