cozy-iiif 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rainer Simon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,29 @@
+# cozy-iiif
+
+**WORK IN PROGRESS**
+
+A developer-friendly collection of abstractions and utilities built on top of the IIIF Commons [@iiif/presentation-3](https://github.com/IIIF-Commons/presentation-3-types) and [@iiif/parser](https://github.com/IIIF-Commons/parser) libraries.
+
+## Features
+
+- Resource identification for any URL: IIIF manifests, manifest, image services, static image, and more.
+- Developer-friendly TypeScript API for parsing and working with IIIF resources.
+- Seamless upgrade from IIIF Presentation API v2 to v3 using `@iiif/parser/`.
+- Preserves access to underlying `@iiif-presentation/3` types.
+- Provides helpers for stitching thumbnails and cropping regions from IIIF Level 0 tilesets.
+
+## Installation
+
+Todo...
+
+## Basic Usage
+
+Todo...
+
+## API
+
+Todo...
+
+## License
+
+MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/Cozy.d.ts

@@ -0,0 +1,4 @@
+import { CozyParseResult } from './types';
+export declare const Cozy: {
+    parseURL: (input: string) => Promise<CozyParseResult>;
+};

package/dist/core/canvas.d.ts

@@ -0,0 +1,5 @@
+import { Canvas } from '@iiif/presentation-3';
+import { CozyImageResource } from '../types';
+export declare const getThumbnailURL: (canvas: Canvas, images?: CozyImageResource[]) => (minSize?: number) => string;
+export declare const normalizeServiceUrl: (url: string) => string;
+export declare const getImages: (canvas: Canvas) => CozyImageResource[];

package/dist/core/image-service.d.ts

@@ -0,0 +1,12 @@
+import { ImageService2, ImageService3, Service } from '@iiif/presentation-3';
+import { Bounds, CozyImageResource } from '../types';
+type ImageService = ImageService2 | ImageService3;
+export declare const isImageService: (data: any) => data is ImageService;
+export declare const parseImageService: (service: Service) => {
+    majorVersion: number;
+    profileLevel: number;
+};
+export declare const getImageURLFromService: (service: ImageService2 | ImageService3, width: number, height: number) => string;
+export declare const getRegionURLFromService: (service: ImageService2 | ImageService3, bounds: Bounds, minSize: number) => string;
+export declare const getRegionURL: (image: CozyImageResource) => (bounds: Bounds, minSize?: number) => string | undefined;
+export {};

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export * from './canvas';
+export * from './image-service';
+export * from './resource';

package/dist/core/resource.d.ts

@@ -0,0 +1,6 @@
+import { InternationalString } from '@iiif/presentation-3';
+import { CozyMetadata } from '../types';
+export declare const getPropertyValue: <T extends unknown = any>(data: any, name: string) => T;
+export declare const getStringValue: (propertyValue: string | InternationalString, locale?: string) => string;
+export declare const getLabel: (data: any) => (locale?: string) => string;
+export declare const getMetadata: (data: any) => (locale?: string) => CozyMetadata[];

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './core';
+export * from './types';
+export * from './Cozy';

package/dist/index.js

@@ -0,0 +1,19 @@
+import { getImages as t, getThumbnailURL as g, normalizeServiceUrl as o } from "./src/core/canvas.js";
+import { getImageURLFromService as m, getRegionURL as i, getRegionURLFromService as l, isImageService as p, parseImageService as R } from "./src/core/image-service.js";
+import { getLabel as c, getMetadata as n, getPropertyValue as v, getStringValue as L } from "./src/core/resource.js";
+import { Cozy as f } from "./src/Cozy.js";
+export {
+  f as Cozy,
+  m as getImageURLFromService,
+  t as getImages,
+  c as getLabel,
+  n as getMetadata,
+  v as getPropertyValue,
+  i as getRegionURL,
+  l as getRegionURLFromService,
+  L as getStringValue,
+  g as getThumbnailURL,
+  p as isImageService,
+  o as normalizeServiceUrl,
+  R as parseImageService
+};

package/dist/level-0/crop-region.d.ts

@@ -0,0 +1,2 @@
+import { Bounds, Level0ImageServiceResource } from '../types';
+export declare const cropRegion: (resource: Level0ImageServiceResource, bounds: Bounds) => Promise<Blob>;

package/dist/level-0/get-thumbnail.d.ts

@@ -0,0 +1,3 @@
+import { Level0ImageServiceResource } from '../types';
+import { Size } from './types';
+export declare const getThumbnail: (resource: Level0ImageServiceResource, minSize?: Partial<Size>) => Promise<Blob>;

package/dist/level-0/index.d.ts

@@ -0,0 +1,2 @@
+export * from './crop-region';
+export * from './get-thumbnail';

package/dist/level-0/index.js

@@ -0,0 +1,6 @@
+import { cropRegion as e } from "../src/level-0/crop-region.js";
+import { getThumbnail as p } from "../src/level-0/get-thumbnail.js";
+export {
+  e as cropRegion,
+  p as getThumbnail
+};

package/dist/level-0/throttled-loader.d.ts

@@ -0,0 +1,7 @@
+interface ThrottledLoaderOpts {
+    callsPerSecond?: number;
+}
+export declare const getThrottledLoader: (opts?: ThrottledLoaderOpts) => {
+    loadImage: import('p-throttle').ThrottledFunction<(url: string) => Promise<HTMLImageElement>>;
+};
+export {};

package/dist/level-0/types.d.ts

@@ -0,0 +1,22 @@
+export interface ImageInfo {
+    id: string;
+    width: number;
+    height: number;
+    tiles: TileInfo[];
+}
+export type Size = {
+    width: number;
+    height: number;
+};
+export interface TileInfo {
+    width: number;
+    height?: number;
+    scaleFactors: number[];
+}
+export interface Tile {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    url: string;
+}

package/dist/src/Cozy.js

@@ -0,0 +1,133 @@
+import { h as u } from "../node_modules/@iiif/parser/dist/chunk-BMMVY4QT.js";
+import { d as l } from "../node_modules/@iiif/parser/dist/chunk-W3DWL6UZ.js";
+import { normalizeServiceUrl as p, getImages as f, getThumbnailURL as I } from "./core/canvas.js";
+import { parseImageService as h } from "./core/image-service.js";
+import { getPropertyValue as g, getMetadata as d, getLabel as m } from "./core/resource.js";
+const S = {
+  parseURL: async (r) => {
+    try {
+      new URL(r);
+    } catch {
+      return {
+        type: "error",
+        code: "INVALID_URL",
+        message: "The provided input is not a valid URL"
+      };
+    }
+    let t;
+    try {
+      if (t = await fetch(r), !t.ok)
+        return {
+          type: "error",
+          code: "INVALID_HTTP_RESPONSE",
+          message: `Server responded: HTTP ${t.status} ${t.statusText ? `(${t.statusText})` : ""}`
+        };
+    } catch (e) {
+      return {
+        type: "error",
+        code: "FETCH_ERROR",
+        message: e instanceof Error ? e.message : "Failed to fetch resource"
+      };
+    }
+    const i = t.headers.get("content-type");
+    if (i != null && i.startsWith("image/"))
+      return {
+        type: "plain-image",
+        url: r
+      };
+    if (i != null && i.includes("text/html"))
+      return {
+        type: "webpage",
+        url: r
+      };
+    try {
+      const e = await t.json(), a = Array.isArray(e["@context"]) ? e["@context"].find((o) => o.includes("iiif.io/api/")) : e["@context"];
+      if (!a)
+        return {
+          type: "error",
+          code: "INVALID_MANIFEST",
+          message: "Missing @context"
+        };
+      if (!g(e, "id"))
+        return {
+          type: "error",
+          code: "INVALID_MANIFEST",
+          message: "Missing id property"
+        };
+      if (a.includes("presentation/2") || a.includes("presentation/3")) {
+        const o = a.includes("presentation/2") ? 2 : 3;
+        return {
+          type: "manifest",
+          url: r,
+          resource: y(e, o)
+        };
+      }
+      if (a.includes("image/2") || a.includes("image/3")) {
+        const o = v(e);
+        return o ? {
+          type: "iiif-image",
+          url: r,
+          resource: o
+        } : {
+          type: "error",
+          code: "INVALID_MANIFEST",
+          message: "Invalid image service definition"
+        };
+      }
+      return {
+        type: "error",
+        code: "INVALID_MANIFEST",
+        message: "JSON resource is not a recognized IIIF format"
+      };
+    } catch {
+      return {
+        type: "error",
+        code: "UNSUPPORTED_FORMAT",
+        message: "Could not parse resource"
+      };
+    }
+  }
+}, y = (r, t) => {
+  const i = (n) => {
+    const o = [];
+    return new l({
+      canvas: [(s) => {
+        s.items && o.push(s);
+      }]
+    }).traverseManifest(n), o.map((s) => {
+      const c = f(s);
+      return {
+        source: s,
+        id: s.id,
+        width: s.width,
+        height: s.height,
+        images: c,
+        getLabel: m(s),
+        getMetadata: d(s),
+        getThumbnailURL: I(s, c)
+      };
+    });
+  }, e = t === 2 ? u(r) : r, a = i(e);
+  return {
+    source: e,
+    id: e.id,
+    majorVersion: t,
+    canvases: a,
+    getLabel: m(e),
+    getMetadata: d(e)
+  };
+}, v = (r) => {
+  const { width: t, height: i } = r, e = h(r);
+  if (e)
+    return {
+      type: e.profileLevel === 0 ? "level0" : "dynamic",
+      service: r,
+      width: t,
+      height: i,
+      majorVersion: e.majorVersion,
+      serviceUrl: p(g(r, "id"))
+    };
+};
+export {
+  S as Cozy
+};

package/dist/src/core/canvas.js

@@ -0,0 +1,63 @@
+import { d as h } from "../../node_modules/@iiif/parser/dist/chunk-W3DWL6UZ.js";
+import { getPropertyValue as d } from "./resource.js";
+import { isImageService as g, getImageURLFromService as f, parseImageService as p, getRegionURL as y } from "./image-service.js";
+const U = (e, n = []) => (s = 400) => {
+  const { width: i, height: a } = e;
+  if (!i || !a) return;
+  const r = i / a, o = r < 1, c = Math.ceil(o ? s / r : s), m = Math.ceil(o ? s : s / r);
+  if (e.thumbnail && e.thumbnail.length > 0) {
+    const t = e.thumbnail[0];
+    if ("service" in t && Array.isArray(t.service)) {
+      const l = t.service.find((v) => g(v));
+      if (l)
+        return f(l, m, c);
+    }
+    if ("id" in t) return t.id;
+  }
+  for (const t of n) {
+    if (t.type === "dynamic" || t.type === "level0")
+      return f(t.service, m, c);
+    if (t.type === "static")
+      return t.url;
+  }
+}, u = (e) => e.endsWith("/info.json") ? e : `${e.endsWith("/") ? e : `${e}/`}info.json`, b = (e) => {
+  const { format: n, height: s, width: i } = e, a = d(e, "id"), r = (e.service || []).find(g), o = r ? p(r) : void 0;
+  if (o) {
+    const c = {
+      source: e,
+      type: o.profileLevel === 0 ? "level0" : "dynamic",
+      service: r,
+      width: i,
+      height: s,
+      majorVersion: o.majorVersion,
+      serviceUrl: u(d(r, "id"))
+    };
+    return o.profileLevel === 0 ? c : {
+      ...c,
+      getRegionURL: y(c)
+    };
+  } else
+    return {
+      source: e,
+      type: "static",
+      width: i,
+      height: s,
+      url: a,
+      format: n
+    };
+}, j = (e) => {
+  const n = [];
+  return new h({
+    annotation: [(i) => {
+      if (i.motivation === "painting") {
+        const r = (i.body ? Array.isArray(i.body) ? i.body : [i.body] : []).filter((o) => o.type === "Image");
+        n.push(...r.map(b));
+      }
+    }]
+  }).traverseCanvas(e), n;
+};
+export {
+  j as getImages,
+  U as getThumbnailURL,
+  u as normalizeServiceUrl
+};

package/dist/src/core/image-service.js

@@ -0,0 +1,36 @@
+import { getPropertyValue as c } from "./resource.js";
+const m = (e) => c(e, "type").startsWith("ImageService"), y = (e) => {
+  const i = c(e, "type"), t = c(e, "context");
+  if (i === "ImageService2" || t != null && t.includes("image/2")) {
+    const l = e, o = ["level0", "level1", "level2"];
+    return { majorVersion: 2, profileLevel: (Array.isArray(l.profile) ? l.profile : [l.profile]).map((r) => o.findIndex((s) => r.toString().includes(s))).filter((r) => r > -1).sort((r, s) => s - r)[0] };
+  } else if (i || t)
+    return { majorVersion: 3, profileLevel: parseInt(e.profile) };
+}, L = (e, i, t) => {
+  const l = c(e, "id"), o = e.profile || "";
+  if (typeof o == "string" && (o.includes("level0") || o.includes("level:0"))) {
+    if ("sizes" in e && Array.isArray(e.sizes)) {
+      const n = e.sizes.sort((r, s) => s.width * s.height - r.width * r.height).filter((r) => r.width * r.height >= i * t)[0];
+      if (n)
+        return `${l}/full/${n.width},${n.height}/0/default.jpg`;
+    }
+    return `${l}/full/full/0/default.jpg`;
+  }
+  return `${l}/full/!${i},${t}/0/default.jpg`;
+}, v = (e, i, t) => {
+  const l = c(e, "id"), o = e.profile || "";
+  if (typeof o == "string" && (o.includes("level0") || o.includes("level:0"))) return;
+  const { x: n, y: r, w: s, h: p } = i, a = s / p, u = a < 1, d = Math.ceil(u ? t / a : t), g = Math.ceil(u ? t : t / a), h = `${Math.round(n)},${Math.round(r)},${Math.round(s)},${Math.round(p)}`;
+  return `${l}/${h}/!${g},${d}/0/default.jpg`;
+}, I = (e) => (i, t = 400) => {
+  if (e.type === "dynamic")
+    return v(e.service, i, t);
+  console.error("Level 0 or static image canvas: unspported");
+};
+export {
+  L as getImageURLFromService,
+  I as getRegionURL,
+  v as getRegionURLFromService,
+  m as isImageService,
+  y as parseImageService
+};

package/dist/src/core/resource.js

@@ -0,0 +1,28 @@
+const c = (e, r) => {
+  let t = e[r];
+  return t || (t = e[`@${r}`]), t;
+}, o = (e, r = "en") => {
+  if (typeof e == "string") return e;
+  const t = e[r];
+  if (t)
+    return t[0];
+  {
+    const n = Object.values(e).reduce((s, a) => Array.isArray(a) ? [...s, ...a] : [...s, a], []);
+    return n.length > 0 ? n[0] : void 0;
+  }
+}, i = (e) => (r = "en") => {
+  const t = c(e, "label");
+  return t ? o(t, r) : void 0;
+}, u = (e) => (r) => {
+  const t = c(e, "metadata");
+  return t ? t.map(({ label: n, value: s }) => ({
+    label: o(n, r),
+    value: o(s, r)
+  })) : [];
+};
+export {
+  i as getLabel,
+  u as getMetadata,
+  c as getPropertyValue,
+  o as getStringValue
+};

package/dist/src/level-0/crop-region.js

@@ -0,0 +1,59 @@
+import { getThrottledLoader as v } from "./throttled-loader.js";
+const y = (e, t) => {
+  const { x: i, y: r, w: a, h: n } = t, o = e.tiles[0].width, s = e.tiles[0].height || e.tiles[0].width;
+  return `${e["@id"]}/${i * o},${r * s},${a},${n}/${o},/0/default.jpg`;
+}, f = (e, t) => {
+  const i = e.tiles[0].width, r = e.tiles[0].height || e.tiles[0].width, a = e.width, n = e.height, o = Math.floor(t.x / i), s = Math.floor(t.y / r), d = Math.ceil((t.x + t.w) / i), x = Math.ceil((t.y + t.h) / r), w = [];
+  for (let c = s; c < x; c++)
+    for (let l = o; l < d; l++) {
+      if (l * i >= a || c * r >= n)
+        continue;
+      const h = Math.min(i, a - l * i), g = Math.min(r, n - c * r);
+      w.push({
+        x: l,
+        y: c,
+        width: h,
+        height: g,
+        url: y(e, { x: l, y: c, w: h, h: g })
+      });
+    }
+  return w;
+}, E = async (e, t) => {
+  const i = await fetch(e.serviceUrl).then((h) => h.json()), r = f(i, t), a = document.createElement("canvas"), n = a.getContext("2d");
+  if (!n)
+    throw new Error("Error initializing canvas context");
+  const o = i.tiles[0].width, s = i.tiles[0].height || i.tiles[0].width, d = (Math.ceil(t.w / o) + 1) * o, x = (Math.ceil(t.h / s) + 1) * s;
+  a.width = d, a.height = x;
+  const w = v({ callsPerSecond: 20 });
+  await Promise.all(r.map(async (h) => {
+    const g = await w.loadImage(h.url), m = h.x * o - t.x, p = h.y * s - t.y;
+    n.drawImage(g, m, p);
+  }));
+  const c = document.createElement("canvas");
+  c.width = t.w, c.height = t.h;
+  const l = c.getContext("2d");
+  if (!l)
+    throw new Error("Error initializing canvas context");
+  return l.drawImage(
+    a,
+    0,
+    0,
+    t.w,
+    t.h,
+    0,
+    0,
+    t.w,
+    t.h
+  ), new Promise((h, g) => {
+    c.toBlob(
+      (m) => {
+        m ? h(m) : g(new Error("Failed to create blob"));
+      },
+      "image/jpeg",
+      0.95
+    );
+  });
+};
+export {
+  E as cropRegion
+};

package/dist/src/level-0/get-thumbnail.js

@@ -0,0 +1,57 @@
+import { getThrottledLoader as w } from "./throttled-loader.js";
+const d = (t, h) => {
+  const e = t.tiles[0].scaleFactors.sort((o, n) => n - o);
+  if (!h)
+    return e[0];
+  const a = h.width ? t.width / h.width : 1 / 0, c = h.height ? t.height / h.height : 1 / 0, i = Math.min(a, c);
+  for (const o of e)
+    if (o <= i)
+      return o;
+  return e[e.length - 1];
+}, u = (t, h) => {
+  const e = d(t, h);
+  let a = Math.ceil(t.width / e), c = Math.ceil(t.height / e);
+  if (h) {
+    const i = t.width / t.height;
+    h.width && a < h.width && (a = h.width, c = Math.ceil(a / i)), h.height && c < h.height && (c = h.height, a = Math.ceil(c * i));
+  }
+  return { width: a, height: c };
+}, M = (t, h) => {
+  const e = d(t, h), a = t.tiles[0].width, c = t.tiles[0].height || t.tiles[0].width, i = Math.ceil(t.width / (a * e)), o = Math.ceil(t.height / (c * e)), n = [];
+  for (let s = 0; s < o; s++)
+    for (let r = 0; r < i; r++) {
+      const l = Math.min(
+        a,
+        (t.width - r * a * e) / e
+      ), g = Math.min(
+        c,
+        (t.height - s * c * e) / e
+      );
+      l <= 0 || g <= 0 || n.push({
+        url: `${t["@id"]}/${r * a * e},${s * c * e},${l * e},${g * e}/${Math.ceil(l)},/0/default.jpg`,
+        width: Math.ceil(l),
+        height: Math.ceil(g),
+        x: r * a,
+        y: s * c
+      });
+    }
+  return n;
+}, p = async (t, h) => {
+  const e = await fetch(t.serviceUrl).then((s) => s.json()), a = M(e, h), c = u(e, h), i = document.createElement("canvas");
+  i.width = c.width, i.height = c.height;
+  const o = i.getContext("2d");
+  if (!o)
+    throw new Error("Error creating canvas context");
+  const n = w();
+  return await Promise.all(a.map(async (s) => {
+    const r = await n.loadImage(s.url);
+    o.drawImage(r, s.x, s.y);
+  })), new Promise((s, r) => {
+    i.toBlob((l) => {
+      l ? s(l) : r(new Error("Failed to create blob"));
+    }, "image/jpeg", 0.85);
+  });
+};
+export {
+  p as getThumbnail
+};

package/dist/src/level-0/throttled-loader.js

@@ -0,0 +1,33 @@
+import a from "../../node_modules/p-throttle/index.js";
+const g = () => {
+  let t = {
+    limit: 5,
+    interval: 1e3
+  }, e = a(t);
+  return {
+    getInstance: () => e,
+    getConfig: () => ({ ...t }),
+    setConfig: (r) => {
+      t = { ...t, ...r }, e = a(t);
+    }
+  };
+}, i = g(), s = (t) => {
+  if (!t) return;
+  const e = i.getConfig();
+  (t.limit && t.limit !== e.limit || t.interval && t.interval !== e.interval) && (console.log("updating throttle config!"), i.setConfig({ ...e, ...t }));
+}, m = (t) => {
+  if (t) {
+    const o = {
+      limit: t.callsPerSecond || 5,
+      interval: 1e3
+    };
+    s(o);
+  }
+  return { loadImage: i.getInstance()((o) => new Promise((l, r) => {
+    const n = new Image();
+    n.crossOrigin = "anonymous", n.onload = () => l(n), n.onerror = r, n.src = o;
+  })) };
+};
+export {
+  m as getThrottledLoader
+};

package/dist/types.d.ts

@@ -0,0 +1,86 @@
+import { Manifest, Canvas, ImageService2, ImageService3, IIIFExternalWebResource } from '@iiif/presentation-3';
+export type CozyParseResult = {
+    type: 'manifest';
+    url: string;
+    resource: CozyManifest;
+} | {
+    type: 'iiif-image';
+    url: string;
+    resource: CozyImageResource;
+} | {
+    type: 'plain-image';
+    url: string;
+} | {
+    type: 'webpage';
+    url: string;
+} | {
+    type: 'error';
+    code: 'INVALID_URL' | 'INVALID_HTTP_RESPONSE' | 'FETCH_ERROR' | 'INVALID_MANIFEST' | 'UNSUPPORTED_FORMAT';
+    message: string;
+};
+export interface CozyManifest {
+    readonly majorVersion: number;
+    readonly source: Manifest;
+    readonly id: string;
+    readonly canvases: CozyCanvas[];
+    getLabel(locale?: string): string;
+    getMetadata(locale?: string): CozyMetadata[];
+}
+export interface CozyCanvas {
+    readonly source: Canvas;
+    readonly id: string;
+    readonly width: number;
+    readonly height: number;
+    readonly images: CozyImageResource[];
+    getLabel(locale?: string): string;
+    getMetadata(locale?: string): CozyMetadata[];
+    getThumbnailURL(minSize?: number): string;
+}
+export interface CozyMetadata {
+    label: string;
+    value: string;
+}
+export type CozyImageResource = StaticImageResource | ImageServiceResource;
+export type ImageServiceResource = DynamicImageServiceResource | Level0ImageServiceResource;
+interface BaseImageResource {
+    readonly source: IIIFExternalWebResource;
+    type: 'static' | 'dynamic' | 'level0';
+    width: number;
+    height: number;
+}
+export interface StaticImageResource extends BaseImageResource {
+    type: 'static';
+    url: string;
+}
+export interface DynamicImageServiceResource extends BaseImageResource {
+    type: 'dynamic';
+    service: ImageService2 | ImageService3;
+    serviceUrl: string;
+    majorVersion: number;
+    getRegionURL(bounds: Bounds, minSize?: number): string;
+}
+export interface Level0ImageServiceResource extends BaseImageResource {
+    type: 'level0';
+    majorVersion: number;
+    service: ImageService2 | ImageService3;
+    serviceUrl: string;
+}
+export interface ImageRequestOptions {
+    width?: number;
+    height?: number;
+    region?: 'full' | 'square' | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    quality?: 'default' | 'color' | 'gray' | 'bitonal';
+    format?: 'jpg' | 'png' | 'gif' | 'webp';
+}
+export interface Bounds {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export {};