import { z } from 'zod';
import { CanvasSchema, ImageSchema } from '../schemas/iiif.js';
import { ImageResource2Schema } from '../schemas/presentation.2.js';
import { AnnotationBody3Schema } from '../schemas/presentation.3.js';
import type { SizeObject, ImageRequest, TileZoomLevel } from '@allmaps/types';
import type { Fit, MajorVersion } from '../lib/types.js';
type CanvasType = z.infer<typeof CanvasSchema>;
type ImageType = z.infer<typeof ImageSchema>;
type EmbeddedImageType = z.infer<typeof AnnotationBody3Schema> | z.infer<typeof ImageResource2Schema>;
declare const ImageTypeString = "image";
/**
 * Parsed IIIF Image, embedded in a Canvas
 * @class EmbeddedImage
 * @property {boolean} embedded - Whether the Image is embedded in a Canvas
 * @property {string} [type] - Resource type, equals 'image'
 * @property {string} uri - URI of Image
 * @property {MajorVersion} majorVersion - IIIF API version of Image
 * @property {boolean} supportsAnyRegionAndSize - Whether the associated Image Service supports any region and size
 * @property {number} [maxWidth] - Maximum width of the associated Image Service
 * @property {number} [maxHeight] - Maximum height of the associated Image Service
 * @property {number} [maxArea] - Maximum area of the associated Image Service
 * @property {number} width - Width of Image
 * @property {number} height - Height of Image
 */
export declare class EmbeddedImage {
    embedded: boolean;
    uri: string;
    type: typeof ImageTypeString;
    maxWidth: number | undefined;
    maxHeight: number | undefined;
    maxArea: number | undefined;
    supportsAnyRegionAndSize: boolean;
    width: number;
    height: number;
    majorVersion: MajorVersion;
    constructor(parsedImage: ImageType | EmbeddedImageType, parsedCanvas?: CanvasType);
    /**
     * Generates a IIIF Image API URL for the requested region and size
     * @param {ImageRequest} imageRequest - Image request object containing the desired region and size of the requested image
     * @returns {string} Image API URL that can be used to fetch the requested image
     */
    getImageUrl(imageRequest: ImageRequest): string;
    getThumbnail(size: SizeObject, mode?: Fit): ImageRequest | ImageRequest[][];
}
/**
 * Parsed IIIF Image
 * @class Image
 * @extends EmbeddedImage
 * @property {TileZoomLevel[]} tileZoomLevels - Array of parsed tile zoom levels
 * @property {Size[]} [sizes] - Array of parsed sizes
 */
export declare class Image extends EmbeddedImage {
    tileZoomLevels: TileZoomLevel[];
    sizes?: SizeObject[];
    embedded: boolean;
    constructor(parsedImage: ImageType);
    /**
     * Parses a IIIF image and returns a [Image](#image) containing the parsed version
     * @param {any} iiifImage - Source data of IIIF Image
     * @param {MajorVersion} [majorVersion=null] - IIIF API version of Image. If not provided, it will be determined automatically
     * @returns {Image} Parsed IIIF Image
     * @static
     */
    static parse(iiifImage: unknown, majorVersion?: MajorVersion | null): Image;
    /**
     * Returns a Image request object for a tile with the requested zoom level, column, and row
     * @param {TileZoomLevel} zoomLevel - Desired zoom level of the requested tile
     * @param {number} column - Column of the requested tile
     * @param {number} row - Row of the requested tile
     * @returns {ImageRequest} Image request object that can be used to fetch the requested tile
     */
    getIiifTile(zoomLevel: TileZoomLevel, column: number, row: number): ImageRequest;
    /**
     * Returns a Image request object for the requested region and size
     * @param {SizeObject} size - Size of the requested thumbnail
     * @param {'cover' | 'contain'} mode - Desired fit mode of the requested thumbnail
     * @returns {ImageRequest} Image request object that can be used to fetch the requested thumbnail
     */
    getThumbnail(size: SizeObject, mode?: Fit): ImageRequest | ImageRequest[][];
}
export {};