ris-ktx2-api 0.1.0-dev.2.4

package/dist/index.d.ts

@@ -0,0 +1,1338 @@
+/**
+ * Creates and loads KTX2 textures.
+ *
+ * `ris-ktx2` provides the implementation. Call {@link IKtx2Factory.initializeAsync}
+ * before {@link IKtx2Factory.loadAsync}, {@link IKtx2Factory.create}, or
+ * {@link IKtx2Factory.createFromBuffer}.
+ */
+export declare interface IKtx2Factory {
+    /**
+     * Initializes the factory and loads the native KTX library.
+     */
+    initializeAsync(): Promise<void>;
+    /**
+     * Loads a KTX or KTX2 texture.
+     *
+     * @param blob - A `File` to read, or a URL string to fetch.
+     * @returns The loaded texture.
+     */
+    loadAsync(blob: string | File): Promise<IKtx2Texture>;
+    /**
+     * Creates a KTX2 texture from {@link IKtxTextureCreateInfo}.
+     *
+     * @param createInfo - Width, height, format, and mip count.
+     * @param storage - Whether to allocate image storage. Optional.
+     * @returns The new texture.
+     */
+    create(createInfo: IKtxTextureCreateInfo, storage?: KtxCreateStorage): IKtx2Texture;
+    /**
+     * Creates a texture from an in-memory KTX or KTX2 file.
+     *
+     * @param buffer - File bytes.
+     * @returns The loaded texture.
+     */
+    createFromBuffer(buffer: ArrayBufferView<ArrayBufferLike>): IKtx2Texture;
+}
+
+/**
+ * A texture loaded from or created as a KTX or KTX2 container.
+ *
+ * `ris-ktx2` implements this interface on top of libktx. Implementations own
+ * the native texture and release it from {@link IKtx2Texture.delete}.
+ * Operations that can fail return a {@link KtxErrorCode}.
+ */
+export declare interface IKtx2Texture {
+    /**
+     * File path of the `.ktx` or `.ktx2` texture when it was loaded from a file.
+     *
+     * Absent for textures created in memory.
+     */
+    readonly filePath?: string;
+    /** Width of the base level, in pixels. */
+    readonly width: number;
+    /** Height of the base level, in pixels. */
+    readonly height: number;
+    /** Size of the texture's image data, in bytes. */
+    readonly dataSize: number;
+    /**
+     * Whether the texture must be transcoded before GPU upload.
+     *
+     * `true` for Basis Universal (ETC1S or UASTC) data that has not yet been
+     * transcoded to a GPU block format.
+     */
+    readonly needsTranscoding: boolean;
+    /** Number of mipmap levels. */
+    readonly numLevels: number;
+    /** Vulkan format of the texture's current image data. */
+    readonly vkFormat: VkFormat;
+    /**
+     * Transcodes Basis Universal data to a GPU format.
+     *
+     * @param transcodeFormat - Target format.
+     * @param transcodeFlags - Transcode options. Pass {@link KtxTranscodeFlags.NONE} for the default.
+     * @returns The error code.
+     */
+    transcodeBasis(transcodeFormat: KtxTranscodeFormat, transcodeFlags: KtxTranscodeFlags): KtxErrorCode;
+    /**
+     * Supercompresses the texture with Basis Universal using explicit parameters.
+     *
+     * @param basisParams - ETC1S or UASTC encoder settings.
+     * @returns The error code.
+     */
+    compressBasis(basisParams: IKtxBasisParams): KtxErrorCode;
+    /**
+     * Supercompresses the texture with Basis Universal at a single quality value.
+     *
+     * Encodes the source images (typically to ETC1S) and stores them
+     * supercompressed inside the KTX2 container. This replaces the original
+     * image data and updates the texture metadata, including the DFD.
+     *
+     * After compression the texture cannot be uploaded directly. Transcode it
+     * to a GPU block format such as ASTC, BC7, or ETC2 first.
+     *
+     * Based on the KTX-Software libktx writer API:
+     * https://github.khronos.org/KTX-Software/libktx/group__writer.html#ga405c44d6daf8ddf83dc805810bf4f989
+     *
+     * @param quality - Compression quality from 1 to 255.
+     * `0` selects the underlying default of 128.
+     * Lower values are faster and smaller, with lower quality.
+     * Higher values are slower and larger, with higher quality.
+     * @returns The error code.
+     */
+    compressBasis(quality: number): KtxErrorCode;
+    /**
+     * Encodes uncompressed 2D images to ASTC and replaces the original data.
+     *
+     * On success the texture fields, including the DFD, describe the ASTC
+     * encoding. The result can be uploaded to a GPU without a further transcode.
+     *
+     * libktx `ktxTexture2_CompressAstc` returns
+     * {@link KtxErrorCode.INVALID_OPERATION} when the images are already
+     * supercompressed, already block-compressed, use a packed format such as
+     * RGB565, have a component size other than 8 bits, or are 1D.
+     * It returns {@link KtxErrorCode.OUT_OF_MEMORY} when encoding cannot
+     * allocate its working buffers.
+     *
+     * @param quality - Compression quality. `0` through `100` is the normal
+     * range: higher is slower and higher quality, lower is faster and lower
+     * quality. The libktx parameter is an unsigned integer, and a negative
+     * value is treated as greater than `100`.
+     * @returns The error code.
+     */
+    compressAstc(quality: number): KtxErrorCode;
+    /**
+     * Reads one image from the texture.
+     *
+     * @param level - Mipmap level. Defaults to `0` in the `ris-ktx2` implementation.
+     * @param layer - Array layer. Defaults to `0` in the `ris-ktx2` implementation.
+     * @param faceSlice - Face or slice index. Defaults to `0` in the `ris-ktx2` implementation.
+     * @returns The image bytes.
+     */
+    getImage(level?: number, layer?: number, faceSlice?: number): Uint8Array;
+    /**
+     * Returns the block layout for a transcode target or Vulkan format.
+     *
+     * {@link KtxTranscodeFormat} and {@link VkFormat} overlap numerically
+     * (for example both use `13`). Implementations must tell them apart by
+     * which enumeration the caller passed, not by the number alone.
+     *
+     * @param format - Transcode target or Vulkan format.
+     * @returns Block width, height, depth, and byte size for `format`.
+     */
+    getTextureFormatInfo(format: KtxTranscodeFormat | VkFormat): TextureFormatInfo;
+    /**
+     * Creates a copy of the texture.
+     *
+     * @returns The copied texture.
+     */
+    createCopy(): IKtx2Texture;
+    /**
+     * Replaces one image with bytes from memory.
+     *
+     * @param level - Mipmap level.
+     * @param layer - Array layer.
+     * @param faceSlice - Face or slice index.
+     * @param imageData - Image bytes.
+     * @returns The error code.
+     */
+    setImageFromMemory(level: number, layer: number, faceSlice: number, imageData: ArrayBufferView): KtxErrorCode;
+    /**
+     * Writes the texture container to memory.
+     *
+     * @returns The KTX or KTX2 file bytes.
+     */
+    writeToMemory(): ArrayBufferView;
+    /**
+     * Deflates the KTX2 data with ZLIB.
+     *
+     * On success, the level index, data size, DFD, data pointer, and
+     * supercompression scheme are updated.
+     *
+     * @param compressionLevel - Compression level from 1 to 9. Lower is faster.
+     * @returns The error code.
+     */
+    deflateZlib(compressionLevel: number): KtxErrorCode;
+    /**
+     * Deflates the KTX2 data with Zstandard.
+     *
+     * On success, the level index, data size, DFD, data pointer, and
+     * supercompression scheme are updated.
+     *
+     * @param compressionLevel - Compression level from 1 to 22. Lower is faster.
+     * Values above 20 use more memory.
+     * @returns The error code.
+     */
+    deflateZstd(compressionLevel: number): KtxErrorCode;
+    /** Deletes the texture and releases its native resources. */
+    delete(): void;
+}
+
+/**
+ * Parameters for Basis Universal supercompression.
+ *
+ * Field meanings follow libktx `ktxBasisParams`. Every field is optional on
+ * this interface; callers that need a non-default ETC1S compression level
+ * must set {@link IKtxBasisParams.compressionLevel} explicitly, because `0`
+ * is a valid level.
+ */
+export declare interface IKtxBasisParams {
+    /**
+     * ETC1S encoding speed versus quality.
+     *
+     * libktx 4.3 documents the range as `[0, 5]`. libktx 4.4 documents
+     * `[0, 6]`, with the higher levels intended for video. Higher values are
+     * slower and produce higher quality. There is no implicit default: `0`
+     * is a valid level, so callers set this themselves. The usual KTX default
+     * level is `2`.
+     */
+    compressionLevel?: number;
+    /**
+     * ETC1S visual quality target.
+     *
+     * Range is `[1, 255]`. Lower values compress more, run faster, and keep
+     * less quality. Higher values compress less, run slower, and keep more
+     * quality. This selects the endpoint and selector counts and the RDO
+     * thresholds. Setting those lower-level parameters yourself overrides the
+     * values chosen from this level. libktx uses the quality level to choose
+     * the RDO thresholds only when the level is above `128`; otherwise those
+     * thresholds stay at their own defaults. When neither this nor both
+     * endpoint and selector counts are set, libktx uses `128`.
+     */
+    qualityLevel?: number;
+    /**
+     * `true` to encode UASTC. `false` to encode ETC1S.
+     */
+    uastc?: boolean;
+    /**
+     * UASTC encoding options.
+     *
+     * A combination of {@link KtxUastcFlags}. Level values in bits 0–3 are
+     * mutually exclusive. Hints at bit 4 and above can be combined with a
+     * level. {@link KtxUastcFlags.FAVOR_UASTC_ERROR} is inside the level mask.
+     */
+    uastcFlags?: KtxUastcFlags;
+    /**
+     * Tune codec parameters for normal maps and set the texture DFD accordingly.
+     *
+     * Disables selector and endpoint RDO. Only valid for linear textures.
+     */
+    normalMap?: boolean;
+    /**
+     * Number of threads used for compression.
+     *
+     * @defaultValue 1
+     */
+    threadCount?: number;
+    /**
+     * Swizzle applied before encoding.
+     *
+     * Four entries, each one of `"r"`, `"g"`, `"b"`, `"a"`, `"0"`, or `"1"`.
+     * The KTX C API types the same value as a 4-character string matching
+     * `/^[rgba01]{4}$/`. Usable with both ETC1S and UASTC.
+     *
+     * If both this swizzle and a pre-swizzle are specified,
+     * `ktxTexture_CompressBasisEx` raises `KTX_INVALID_OPERATION`.
+     */
+    inputSwizzle?: string[];
+    /**
+     * Enable Rate Distortion Optimization post-processing for UASTC.
+     */
+    uastcRDO?: boolean;
+    /**
+     * UASTC RDO quality scalar (lambda).
+     *
+     * Lower values yield higher quality and larger LZ-compressed files.
+     * Higher values yield lower quality and smaller LZ-compressed files.
+     * A useful range to try is `[0.2, 4]`. The full range is `[0.001, 50]`.
+     *
+     * @defaultValue 1
+     */
+    uastcRDOQualityScalar?: number;
+    /**
+     * When `true`, the encoder may print operation details.
+     */
+    verbose?: boolean;
+}
+
+/**
+ * Parameters for creating an empty 2D KTX2 texture.
+ */
+export declare interface IKtxTextureCreateInfo {
+    /** Base width of the texture, in pixels. */
+    baseWidth: number;
+    /** Base height of the texture, in pixels. */
+    baseHeight: number;
+    /**
+     * Vulkan format of the image data.
+     *
+     * When omitted, the `ris-ktx2` implementation uses {@link VkFormat.R8G8B8A8_SRGB}.
+     */
+    vkFormat?: VkFormat;
+    /**
+     * Number of mipmap levels.
+     *
+     * @defaultValue 1
+     */
+    numLevels?: number;
+}
+
+/**
+ * How image storage is allocated when a KTX2 texture is created.
+ *
+ * Values match libktx `ktxTextureCreateStorageEnum`:
+ * `KTX_TEXTURE_CREATE_NO_STORAGE` is `0` and
+ * `KTX_TEXTURE_CREATE_ALLOC_STORAGE` is `1`.
+ */
+export declare enum KtxCreateStorage {
+    /** Do not allocate image storage. */
+    NO_STORAGE = 0,
+    /** Allocate image storage for the texture. */
+    ALLOC_STORAGE = 1
+}
+
+/**
+ * Result codes returned by KTX2 texture operations.
+ *
+ * Names and numeric values match libktx `ktx_error_code_e`.
+ * `KTX_ERROR_MAX_ENUM` is not a member: in libktx it aliases
+ * {@link KtxErrorCode.DECOMPRESS_CHECKSUM_ERROR} and is not a distinct result.
+ */
+export declare enum KtxErrorCode {
+    /** The operation succeeded. */
+    SUCCESS = 0,
+    /** The file data does not match the KTX specification. */
+    FILE_DATA_ERROR = 1,
+    /** The file is a pipe or a named pipe. */
+    FILE_ISPIPE = 2,
+    /** The target file could not be opened. */
+    FILE_OPEN_FAILED = 3,
+    /** The operation would exceed the maximum file size. */
+    FILE_OVERFLOW = 4,
+    /** Reading the file failed. */
+    FILE_READ_ERROR = 5,
+    /** Seeking in the file failed. */
+    FILE_SEEK_ERROR = 6,
+    /** The file ended before the requested data was read. */
+    FILE_UNEXPECTED_EOF = 7,
+    /** Writing the file failed. */
+    FILE_WRITE_ERROR = 8,
+    /** An OpenGL call failed. */
+    GL_ERROR = 9,
+    /** The operation is not allowed in the current state. */
+    INVALID_OPERATION = 10,
+    /** A parameter value was not valid. */
+    INVALID_VALUE = 11,
+    /** A metadata key was missing, or a required GPU entry point was not found. */
+    NOT_FOUND = 12,
+    /** Not enough memory to complete the operation. */
+    OUT_OF_MEMORY = 13,
+    /** Transcoding a block-compressed texture failed. */
+    TRANSCODE_FAILED = 14,
+    /** The file is not a KTX file. */
+    UNKNOWN_FILE_FORMAT = 15,
+    /** The file requests a texture type this library does not support. */
+    UNSUPPORTED_TEXTURE_TYPE = 16,
+    /** The feature is not built into this library, or it is not implemented yet. */
+    UNSUPPORTED_FEATURE = 17,
+    /** An OpenGL or Vulkan dependency is not linked into the application. */
+    LIBRARY_NOT_LINKED = 18,
+    /** The decompressed byte count does not match the expected size. */
+    DECOMPRESS_LENGTH_ERROR = 19,
+    /** A checksum did not match while decompressing. */
+    DECOMPRESS_CHECKSUM_ERROR = 20
+}
+
+/**
+ * Flags that select options for Basis Universal transcoding.
+ *
+ * Numeric values match the libktx `ktx_transcode_flag_bits_e` enumerators.
+ * Combine them with bitwise OR when more than one option applies.
+ */
+export declare enum KtxTranscodeFlags {
+    /** No special transcoding options. */
+    NONE = 0,
+    /**
+     * For PVRTC1, decode a non-power-of-two ETC1S level to the next larger
+     * power of two.
+     *
+     * libktx still documents this option as not implemented. It is ignored
+     * when the slice dimensions are already powers of two.
+     */
+    PVRTC_DECODE_TO_NEXT_POW2 = 2,
+    /**
+     * When transcoding to an opaque format, decode the alpha slice instead of
+     * the color slice if the Basis data has alpha. Has no effect when there
+     * is no alpha data.
+     */
+    TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS = 4,
+    /**
+     * Request a higher-quality transcode of UASTC to BC1, BC3, ETC2 EAC R11,
+     * or ETC2 EAC RG11. Unused by other UASTC transcode targets.
+     */
+    HIGH_QUALITY = 32
+}
+
+/**
+ * Target formats for transcoding a Basis Universal (ETC1S or UASTC) texture.
+ *
+ * Numeric values match the libktx `ktx_transcode_fmt_e` enumerators.
+ * Gaps in the numbering are formats libktx does not expose (there is no
+ * equivalent `VkFormat` for the omitted targets).
+ */
+export declare enum KtxTranscodeFormat {
+    /**
+     * Opaque ETC1 RGB. Returns alpha data instead when
+     * {@link KtxTranscodeFlags.TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS} is set.
+     */
+    KTX_TTF_ETC1_RGB = 0,
+    /**
+     * ETC2 RGBA. An EAC alpha block followed by an ETC1 block.
+     * Textures without alpha get an opaque alpha channel.
+     */
+    ETC2_RGBA = 1,
+    /**
+     * Opaque BC1 RGB. Returns alpha data instead when
+     * {@link KtxTranscodeFlags.TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS} is set.
+     */
+    KTX_TTF_BC1_RGB = 2,
+    /**
+     * BC3 compressed RGBA.
+     * Common on desktop devices. Widely supported block compression for color textures.
+     */
+    BC3_RGBA = 3,
+    /**
+     * Single-channel BC4. The red channel is the opaque or alpha green component,
+     * depending on {@link KtxTranscodeFlags.TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS}.
+     */
+    KTX_TTF_BC4_R = 4,
+    /**
+     * Two-channel BC5 (red and green). Intended for tangent-space normal maps.
+     * The texture should have an alpha channel; otherwise green is 255.
+     */
+    KTX_TTF_BC5_RG = 5,
+    /**
+     * BC7 compressed RGBA.
+     * High quality block compression for color textures.
+     * Supports an alpha channel and is suitable for diffuse and physically based textures.
+     */
+    BC7_RGBA = 6,
+    /**
+     * Opaque PVRTC1 4bpp RGB. Returns alpha data instead when
+     * {@link KtxTranscodeFlags.TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS} is set.
+     */
+    KTX_TTF_PVRTC1_4_RGB = 8,
+    /**
+     * PVRTC1 4bpp RGBA. Useful for simple opacity maps.
+     * If the texture has no alpha channel, PVRTC1 4bpp RGB is used instead.
+     */
+    KTX_TTF_PVRTC1_4_RGBA = 9,
+    /**
+     * ASTC 4×4 RGBA.
+     * Common on mobile devices, especially Apple. High quality block compression
+     * for color textures, including an alpha channel.
+     */
+    ASTC_4X4_RGBA = 10,
+    /**
+     * Uncompressed 32bpp RGBA in raster order (R, G, B, A).
+     * Supported on all devices.
+     */
+    RGBA32 = 13,
+    /** Uncompressed 16bpp RGB565 in raster order, with red in the high bits. */
+    KTX_TTF_RGB565 = 14,
+    /** Uncompressed 16bpp BGR565 in raster order, with red in the low bits. */
+    KTX_TTF_BGR565 = 15,
+    /** Uncompressed 16bpp RGBA4444 in raster order. */
+    KTX_TTF_RGBA4444 = 16,
+    /**
+     * Opaque PVRTC2 4bpp RGB. Supports arbitrary dimensions, unlike PVRTC1.
+     */
+    KTX_TTF_PVRTC2_4_RGB = 18,
+    /** PVRTC2 4bpp RGBA. Premultiplied alpha is recommended. */
+    KTX_TTF_PVRTC2_4_RGBA = 19,
+    /**
+     * Unsigned ETC2 EAC R11. The red channel is the opaque or alpha green
+     * component, depending on
+     * {@link KtxTranscodeFlags.TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS}.
+     */
+    KTX_TTF_ETC2_EAC_R11 = 20,
+    /**
+     * Unsigned ETC2 EAC RG11. Intended for tangent-space normal maps.
+     * The texture should have an alpha channel; otherwise green is 255.
+     */
+    KTX_TTF_ETC2_EAC_RG11 = 21,
+    /**
+     * Selects {@link KtxTranscodeFormat.KTX_TTF_ETC1_RGB} or
+     * {@link KtxTranscodeFormat.ETC2_RGBA} according to whether the texture has alpha.
+     */
+    KTX_TTF_ETC = 22,
+    /**
+     * Selects {@link KtxTranscodeFormat.KTX_TTF_BC1_RGB} or
+     * {@link KtxTranscodeFormat.BC3_RGBA} according to whether the texture has alpha.
+     */
+    BC1_OR_3 = 23,
+    /** No transcode format selected. */
+    NO_SELECTION = 2147483647
+}
+
+/**
+ * UASTC encoding configuration flags.
+ *
+ * Packed bitfield matching libktx `ktx_pack_uastc_flag_bits_e`.
+ * Bits 0–3 hold the compression level ({@link KtxUastcFlags.LEVEL_MASK}).
+ * {@link KtxUastcFlags.FAVOR_UASTC_ERROR} is `8`, so it sits inside that mask:
+ * combining it with a level changes the value `LEVEL_MASK` extracts.
+ * Hints at bit 4 and above (`16`, `64`, `128`, `256`) combine with a level
+ * with bitwise OR and leave bits 0–3 unchanged.
+ */
+export declare enum KtxUastcFlags {
+    /**
+     * Fastest compression (lowest quality, highest speed). About 43.45 dB.
+     */
+    LEVEL_FASTEST = 0,
+    /**
+     * Faster compression. About 46.49 dB.
+     */
+    LEVEL_FASTER = 1,
+    /**
+     * Default compression level. About 47.47 dB.
+     */
+    LEVEL_DEFAULT = 2,
+    /**
+     * Slower compression (higher quality). About 48.01 dB.
+     */
+    LEVEL_SLOWER = 3,
+    /**
+     * Very slow compression (highest quality). About 48.24 dB.
+     */
+    LEVEL_VERY_SLOW = 4,
+    /**
+     * Mask for the compression level in bits 0–3.
+     */
+    LEVEL_MASK = 15,
+    /**
+     * Optimize encoding for the lowest UASTC reconstruction error.
+     */
+    FAVOR_UASTC_ERROR = 8,
+    /**
+     * Optimize encoding for the lowest BC7 decode error.
+     */
+    FAVOR_BC7_ERROR = 16,
+    /**
+     * Hint to optimize for faster ETC1 transcoding.
+     */
+    ETC1_FASTER_HINTS = 64,
+    /**
+     * Hint to optimize for the fastest ETC1 transcoding.
+     */
+    ETC1_FASTEST_HINTS = 128,
+    /**
+     * Disables flip-and-individual optimizations for ETC1 transcoding.
+     */
+    ETC1_DISABLE_FLIP_AND_INDIVIDUAL = 256
+}
+
+/**
+ * Describes how a texture format is laid out in memory, in blocks.
+ *
+ * For uncompressed formats a block is one pixel:
+ * `blockWidth` and `blockHeight` are `1`, and `bytesPerBlock` is the bytes per pixel.
+ *
+ * For compressed formats such as BC7, a block is a group of pixels
+ * (typically 4×4) stored in a fixed number of bytes.
+ */
+export declare class TextureFormatInfo {
+    /** Width of one block, in pixels. */
+    readonly blockWidth: number;
+    /** Height of one block, in pixels. */
+    readonly blockHeight: number;
+    /** Depth of one block, in pixels. */
+    readonly blockDepth: number;
+    /** Size of one block, in bytes. */
+    readonly bytesPerBlock: number;
+    /**
+     * Average number of bytes used per pixel.
+     *
+     * For uncompressed formats this is the bytes per pixel.
+     * For compressed formats this is the average storage cost per pixel.
+     */
+    get pixelSize(): number;
+    /**
+     * Creates a block-layout description.
+     *
+     * @param blockWidth - Block width, in pixels.
+     * @param blockHeight - Block height, in pixels.
+     * @param blockDepth - Block depth, in pixels.
+     * @param bytesPerBlock - Bytes stored in one block.
+     */
+    constructor(blockWidth: number, blockHeight: number, blockDepth: number, bytesPerBlock: number);
+    /**
+     * Number of blocks needed to cover `width` pixels.
+     *
+     * @param width - Texture width, in pixels.
+     * @returns Block count, rounded up to a whole block.
+     */
+    getBlocksPerRow(width: number): number;
+    /**
+     * Number of block rows needed to cover `height` pixels.
+     *
+     * @param height - Texture height, in pixels.
+     * @returns Block-row count, rounded up to a whole block.
+     */
+    getBlocksPerColumn(height: number): number;
+    /**
+     * Number of block slices needed to cover `depth` pixels.
+     *
+     * @param depth - Texture depth, in pixels.
+     * @returns Block-slice count, rounded up to a whole block.
+     */
+    getBlocksPerSlice(depth: number): number;
+    /**
+     * Unaligned number of bytes in one row of blocks.
+     *
+     * @param width - Texture width, in pixels.
+     * @returns Bytes per row, without a 256-byte alignment.
+     */
+    getBytesPerRow(width: number): number;
+    /**
+     * WebGPU `bytesPerRow` for `width`.
+     *
+     * WebGPU requires `bytesPerRow` to be a multiple of 256.
+     *
+     * @param width - Texture width, in pixels.
+     * @returns `getBytesPerRow(width)` rounded up to a multiple of 256.
+     */
+    getAlignedBytesPerRow(width: number): number;
+    /**
+     * Byte size of one 2D mip level.
+     *
+     * @param width - Level width, in pixels.
+     * @param height - Level height, in pixels.
+     * @returns Level size, in bytes.
+     */
+    getDataSize(width: number, height: number): number;
+    /**
+     * Byte size of one 3D mip level.
+     *
+     * @param width - Level width, in pixels.
+     * @param height - Level height, in pixels.
+     * @param depth - Level depth, in pixels.
+     * @returns Level size, in bytes.
+     */
+    getDataSize3D(width: number, height: number, depth: number): number;
+    /**
+     * BC7 layout: 4×4 blocks, 16 bytes per block.
+     *
+     * @returns The BC7 {@link TextureFormatInfo}.
+     */
+    static bc7(): TextureFormatInfo;
+    /**
+     * BC3 layout: 4×4 blocks, 16 bytes per block.
+     *
+     * @returns The BC3 {@link TextureFormatInfo}.
+     */
+    static bc3(): TextureFormatInfo;
+    /**
+     * ETC2 RGBA layout: 4×4 blocks, 16 bytes per block.
+     *
+     * @returns The ETC2 RGBA {@link TextureFormatInfo}.
+     */
+    static etc2rgba(): TextureFormatInfo;
+    /**
+     * ASTC 4×4 RGBA layout: 4×4 blocks, 16 bytes per block.
+     *
+     * @returns The ASTC 4×4 RGBA {@link TextureFormatInfo}.
+     */
+    static astc4x4rgba(): TextureFormatInfo;
+    /**
+     * Uncompressed 8-bit 4-channel layout: 1×1 blocks, 4 bytes per pixel.
+     *
+     * Channel order does not change the size. `B8G8R8A8_*` and
+     * `A8B8G8R8_*_PACK32` use this same layout.
+     *
+     * @returns The 4-byte {@link TextureFormatInfo}.
+     */
+    static rgba32(): TextureFormatInfo;
+    /**
+     * `D24_UNORM_S8_UINT` layout: 4 bytes per pixel.
+     *
+     * @returns The depth/stencil {@link TextureFormatInfo}.
+     */
+    static depth24Stencil8(): TextureFormatInfo;
+    /**
+     * `D32_SFLOAT` layout: 4 bytes per pixel.
+     *
+     * @returns The 32-bit float depth {@link TextureFormatInfo}.
+     */
+    static depth32float(): TextureFormatInfo;
+    /**
+     * Block layout for a Vulkan format this package knows how to size.
+     *
+     * sRGB, signed, integer, and scaled variants share the block size of the
+     * matching unsigned normalized format. Channel order does not change the
+     * byte size.
+     *
+     * - `R8G8B8A8_*`, `B8G8R8A8_*`, and `A8B8G8R8_*_PACK32` use {@link TextureFormatInfo.rgba32}.
+     * - `D24_UNORM_S8_UINT` uses {@link TextureFormatInfo.depth24Stencil8}.
+     * - `D32_SFLOAT` uses {@link TextureFormatInfo.depth32float}.
+     * - `BC3_UNORM_BLOCK` and `BC3_SRGB_BLOCK` use {@link TextureFormatInfo.bc3}.
+     * - `BC7_UNORM_BLOCK` and `BC7_SRGB_BLOCK` use {@link TextureFormatInfo.bc7}.
+     * - `ETC2_R8G8B8A8_UNORM_BLOCK` and `ETC2_R8G8B8A8_SRGB_BLOCK` use {@link TextureFormatInfo.etc2rgba}.
+     * - `ASTC_4X4_UNORM_BLOCK`, `ASTC_4X4_SRGB_BLOCK`, and `ASTC_4X4_SFLOAT_BLOCK`
+     *   use {@link TextureFormatInfo.astc4x4rgba}. `ASTC_4X4_SFLOAT_BLOCK_EXT`
+     *   is the same value as `ASTC_4X4_SFLOAT_BLOCK`.
+     *
+     * @param vkFormat - Vulkan format.
+     * @returns The matching layout.
+     * @throws {Error} When `vkFormat` has no layout in this package.
+     */
+    static fromVkFormat(vkFormat: VkFormat): TextureFormatInfo;
+}
+
+/**
+ * Vulkan `VkFormat` enumerators.
+ *
+ * Names and numeric values match the Vulkan API so they can be stored in
+ * KTX2 files and passed through to graphics APIs. Extension enumerators that
+ * share a value with a core enumerator are documented as aliases.
+ * See THIRD_PARTY_NOTICES.md.
+ */
+export declare enum VkFormat {
+    /** No format is specified. */
+    UNDEFINED = 0,
+    /** 4-bit red and green, unsigned normalized, packed into an 8-bit word. */
+    R4G4_UNORM_PACK8 = 1,
+    /** 4-bit red, green, blue, and alpha, unsigned normalized, packed into a 16-bit word. */
+    R4G4B4A4_UNORM_PACK16 = 2,
+    /** 4-bit blue, green, red, and alpha, unsigned normalized, packed into a 16-bit word. */
+    B4G4R4A4_UNORM_PACK16 = 3,
+    /** 5-bit red, 6-bit green, and 5-bit blue, unsigned normalized, packed into a 16-bit word. */
+    R5G6B5_UNORM_PACK16 = 4,
+    /** 5-bit blue, 6-bit green, and 5-bit red, unsigned normalized, packed into a 16-bit word. */
+    B5G6R5_UNORM_PACK16 = 5,
+    /** 5-bit red, 5-bit green, 5-bit blue, and 1-bit alpha, unsigned normalized, packed into a 16-bit word. */
+    R5G5B5A1_UNORM_PACK16 = 6,
+    /** 5-bit blue, 5-bit green, 5-bit red, and 1-bit alpha, unsigned normalized, packed into a 16-bit word. */
+    B5G5R5A1_UNORM_PACK16 = 7,
+    /** 1-bit alpha, 5-bit red, 5-bit green, and 5-bit blue, unsigned normalized, packed into a 16-bit word. */
+    A1R5G5B5_UNORM_PACK16 = 8,
+    /** 8-bit red, unsigned normalized. */
+    R8_UNORM = 9,
+    /** 8-bit red, signed normalized. */
+    R8_SNORM = 10,
+    /** 8-bit red, unsigned scaled. */
+    R8_USCALED = 11,
+    /** 8-bit red, signed scaled. */
+    R8_SSCALED = 12,
+    /** 8-bit red, unsigned integer. */
+    R8_UINT = 13,
+    /** 8-bit red, signed integer. */
+    R8_SINT = 14,
+    /** 8-bit red, sRGB. */
+    R8_SRGB = 15,
+    /** 8-bit red and green, unsigned normalized. */
+    R8G8_UNORM = 16,
+    /** 8-bit red and green, signed normalized. */
+    R8G8_SNORM = 17,
+    /** 8-bit red and green, unsigned scaled. */
+    R8G8_USCALED = 18,
+    /** 8-bit red and green, signed scaled. */
+    R8G8_SSCALED = 19,
+    /** 8-bit red and green, unsigned integer. */
+    R8G8_UINT = 20,
+    /** 8-bit red and green, signed integer. */
+    R8G8_SINT = 21,
+    /** 8-bit red and green, sRGB. */
+    R8G8_SRGB = 22,
+    /** 8-bit red, green, and blue, unsigned normalized. */
+    R8G8B8_UNORM = 23,
+    /** 8-bit red, green, and blue, signed normalized. */
+    R8G8B8_SNORM = 24,
+    /** 8-bit red, green, and blue, unsigned scaled. */
+    R8G8B8_USCALED = 25,
+    /** 8-bit red, green, and blue, signed scaled. */
+    R8G8B8_SSCALED = 26,
+    /** 8-bit red, green, and blue, unsigned integer. */
+    R8G8B8_UINT = 27,
+    /** 8-bit red, green, and blue, signed integer. */
+    R8G8B8_SINT = 28,
+    /** 8-bit red, green, and blue, sRGB. */
+    R8G8B8_SRGB = 29,
+    /** 8-bit blue, green, and red, unsigned normalized. */
+    B8G8R8_UNORM = 30,
+    /** 8-bit blue, green, and red, signed normalized. */
+    B8G8R8_SNORM = 31,
+    /** 8-bit blue, green, and red, unsigned scaled. */
+    B8G8R8_USCALED = 32,
+    /** 8-bit blue, green, and red, signed scaled. */
+    B8G8R8_SSCALED = 33,
+    /** 8-bit blue, green, and red, unsigned integer. */
+    B8G8R8_UINT = 34,
+    /** 8-bit blue, green, and red, signed integer. */
+    B8G8R8_SINT = 35,
+    /** 8-bit blue, green, and red, sRGB. */
+    B8G8R8_SRGB = 36,
+    /** 8-bit red, green, blue, and alpha, unsigned normalized. */
+    R8G8B8A8_UNORM = 37,
+    /** 8-bit red, green, blue, and alpha, signed normalized. */
+    R8G8B8A8_SNORM = 38,
+    /** 8-bit red, green, blue, and alpha, unsigned scaled. */
+    R8G8B8A8_USCALED = 39,
+    /** 8-bit red, green, blue, and alpha, signed scaled. */
+    R8G8B8A8_SSCALED = 40,
+    /** 8-bit red, green, blue, and alpha, unsigned integer. */
+    R8G8B8A8_UINT = 41,
+    /** 8-bit red, green, blue, and alpha, signed integer. */
+    R8G8B8A8_SINT = 42,
+    /** 8-bit red, green, blue, and alpha, sRGB. */
+    R8G8B8A8_SRGB = 43,
+    /** 8-bit blue, green, red, and alpha, unsigned normalized. */
+    B8G8R8A8_UNORM = 44,
+    /** 8-bit blue, green, red, and alpha, signed normalized. */
+    B8G8R8A8_SNORM = 45,
+    /** 8-bit blue, green, red, and alpha, unsigned scaled. */
+    B8G8R8A8_USCALED = 46,
+    /** 8-bit blue, green, red, and alpha, signed scaled. */
+    B8G8R8A8_SSCALED = 47,
+    /** 8-bit blue, green, red, and alpha, unsigned integer. */
+    B8G8R8A8_UINT = 48,
+    /** 8-bit blue, green, red, and alpha, signed integer. */
+    B8G8R8A8_SINT = 49,
+    /** 8-bit blue, green, red, and alpha, sRGB. */
+    B8G8R8A8_SRGB = 50,
+    /** 8-bit alpha, blue, green, and red, unsigned normalized, packed into a 32-bit word. */
+    A8B8G8R8_UNORM_PACK32 = 51,
+    /** 8-bit alpha, blue, green, and red, signed normalized, packed into a 32-bit word. */
+    A8B8G8R8_SNORM_PACK32 = 52,
+    /** 8-bit alpha, blue, green, and red, unsigned scaled, packed into a 32-bit word. */
+    A8B8G8R8_USCALED_PACK32 = 53,
+    /** 8-bit alpha, blue, green, and red, signed scaled, packed into a 32-bit word. */
+    A8B8G8R8_SSCALED_PACK32 = 54,
+    /** 8-bit alpha, blue, green, and red, unsigned integer, packed into a 32-bit word. */
+    A8B8G8R8_UINT_PACK32 = 55,
+    /** 8-bit alpha, blue, green, and red, signed integer, packed into a 32-bit word. */
+    A8B8G8R8_SINT_PACK32 = 56,
+    /** 8-bit alpha, blue, green, and red, sRGB, packed into a 32-bit word. */
+    A8B8G8R8_SRGB_PACK32 = 57,
+    /** 2-bit alpha, 10-bit red, 10-bit green, and 10-bit blue, unsigned normalized, packed into a 32-bit word. */
+    A2R10G10B10_UNORM_PACK32 = 58,
+    /** 2-bit alpha, 10-bit red, 10-bit green, and 10-bit blue, signed normalized, packed into a 32-bit word. */
+    A2R10G10B10_SNORM_PACK32 = 59,
+    /** 2-bit alpha, 10-bit red, 10-bit green, and 10-bit blue, unsigned scaled, packed into a 32-bit word. */
+    A2R10G10B10_USCALED_PACK32 = 60,
+    /** 2-bit alpha, 10-bit red, 10-bit green, and 10-bit blue, signed scaled, packed into a 32-bit word. */
+    A2R10G10B10_SSCALED_PACK32 = 61,
+    /** 2-bit alpha, 10-bit red, 10-bit green, and 10-bit blue, unsigned integer, packed into a 32-bit word. */
+    A2R10G10B10_UINT_PACK32 = 62,
+    /** 2-bit alpha, 10-bit red, 10-bit green, and 10-bit blue, signed integer, packed into a 32-bit word. */
+    A2R10G10B10_SINT_PACK32 = 63,
+    /** 2-bit alpha, 10-bit blue, 10-bit green, and 10-bit red, unsigned normalized, packed into a 32-bit word. */
+    A2B10G10R10_UNORM_PACK32 = 64,
+    /** 2-bit alpha, 10-bit blue, 10-bit green, and 10-bit red, signed normalized, packed into a 32-bit word. */
+    A2B10G10R10_SNORM_PACK32 = 65,
+    /** 2-bit alpha, 10-bit blue, 10-bit green, and 10-bit red, unsigned scaled, packed into a 32-bit word. */
+    A2B10G10R10_USCALED_PACK32 = 66,
+    /** 2-bit alpha, 10-bit blue, 10-bit green, and 10-bit red, signed scaled, packed into a 32-bit word. */
+    A2B10G10R10_SSCALED_PACK32 = 67,
+    /** 2-bit alpha, 10-bit blue, 10-bit green, and 10-bit red, unsigned integer, packed into a 32-bit word. */
+    A2B10G10R10_UINT_PACK32 = 68,
+    /** 2-bit alpha, 10-bit blue, 10-bit green, and 10-bit red, signed integer, packed into a 32-bit word. */
+    A2B10G10R10_SINT_PACK32 = 69,
+    /** 16-bit red, unsigned normalized. */
+    R16_UNORM = 70,
+    /** 16-bit red, signed normalized. */
+    R16_SNORM = 71,
+    /** 16-bit red, unsigned scaled. */
+    R16_USCALED = 72,
+    /** 16-bit red, signed scaled. */
+    R16_SSCALED = 73,
+    /** 16-bit red, unsigned integer. */
+    R16_UINT = 74,
+    /** 16-bit red, signed integer. */
+    R16_SINT = 75,
+    /** 16-bit red, signed floating-point. */
+    R16_SFLOAT = 76,
+    /** 16-bit red and green, unsigned normalized. */
+    R16G16_UNORM = 77,
+    /** 16-bit red and green, signed normalized. */
+    R16G16_SNORM = 78,
+    /** 16-bit red and green, unsigned scaled. */
+    R16G16_USCALED = 79,
+    /** 16-bit red and green, signed scaled. */
+    R16G16_SSCALED = 80,
+    /** 16-bit red and green, unsigned integer. */
+    R16G16_UINT = 81,
+    /** 16-bit red and green, signed integer. */
+    R16G16_SINT = 82,
+    /** 16-bit red and green, signed floating-point. */
+    R16G16_SFLOAT = 83,
+    /** 16-bit red, green, and blue, unsigned normalized. */
+    R16G16B16_UNORM = 84,
+    /** 16-bit red, green, and blue, signed normalized. */
+    R16G16B16_SNORM = 85,
+    /** 16-bit red, green, and blue, unsigned scaled. */
+    R16G16B16_USCALED = 86,
+    /** 16-bit red, green, and blue, signed scaled. */
+    R16G16B16_SSCALED = 87,
+    /** 16-bit red, green, and blue, unsigned integer. */
+    R16G16B16_UINT = 88,
+    /** 16-bit red, green, and blue, signed integer. */
+    R16G16B16_SINT = 89,
+    /** 16-bit red, green, and blue, signed floating-point. */
+    R16G16B16_SFLOAT = 90,
+    /** 16-bit red, green, blue, and alpha, unsigned normalized. */
+    R16G16B16A16_UNORM = 91,
+    /** 16-bit red, green, blue, and alpha, signed normalized. */
+    R16G16B16A16_SNORM = 92,
+    /** 16-bit red, green, blue, and alpha, unsigned scaled. */
+    R16G16B16A16_USCALED = 93,
+    /** 16-bit red, green, blue, and alpha, signed scaled. */
+    R16G16B16A16_SSCALED = 94,
+    /** 16-bit red, green, blue, and alpha, unsigned integer. */
+    R16G16B16A16_UINT = 95,
+    /** 16-bit red, green, blue, and alpha, signed integer. */
+    R16G16B16A16_SINT = 96,
+    /** 16-bit red, green, blue, and alpha, signed floating-point. */
+    R16G16B16A16_SFLOAT = 97,
+    /** 32-bit red, unsigned integer. */
+    R32_UINT = 98,
+    /** 32-bit red, signed integer. */
+    R32_SINT = 99,
+    /** 32-bit red, signed floating-point. */
+    R32_SFLOAT = 100,
+    /** 32-bit red and green, unsigned integer. */
+    R32G32_UINT = 101,
+    /** 32-bit red and green, signed integer. */
+    R32G32_SINT = 102,
+    /** 32-bit red and green, signed floating-point. */
+    R32G32_SFLOAT = 103,
+    /** 32-bit red, green, and blue, unsigned integer. */
+    R32G32B32_UINT = 104,
+    /** 32-bit red, green, and blue, signed integer. */
+    R32G32B32_SINT = 105,
+    /** 32-bit red, green, and blue, signed floating-point. */
+    R32G32B32_SFLOAT = 106,
+    /** 32-bit red, green, blue, and alpha, unsigned integer. */
+    R32G32B32A32_UINT = 107,
+    /** 32-bit red, green, blue, and alpha, signed integer. */
+    R32G32B32A32_SINT = 108,
+    /** 32-bit red, green, blue, and alpha, signed floating-point. */
+    R32G32B32A32_SFLOAT = 109,
+    /** 64-bit red, unsigned integer. */
+    R64_UINT = 110,
+    /** 64-bit red, signed integer. */
+    R64_SINT = 111,
+    /** 64-bit red, signed floating-point. */
+    R64_SFLOAT = 112,
+    /** 64-bit red and green, unsigned integer. */
+    R64G64_UINT = 113,
+    /** 64-bit red and green, signed integer. */
+    R64G64_SINT = 114,
+    /** 64-bit red and green, signed floating-point. */
+    R64G64_SFLOAT = 115,
+    /** 64-bit red, green, and blue, unsigned integer. */
+    R64G64B64_UINT = 116,
+    /** 64-bit red, green, and blue, signed integer. */
+    R64G64B64_SINT = 117,
+    /** 64-bit red, green, and blue, signed floating-point. */
+    R64G64B64_SFLOAT = 118,
+    /** 64-bit red, green, blue, and alpha, unsigned integer. */
+    R64G64B64A64_UINT = 119,
+    /** 64-bit red, green, blue, and alpha, signed integer. */
+    R64G64B64A64_SINT = 120,
+    /** 64-bit red, green, blue, and alpha, signed floating-point. */
+    R64G64B64A64_SFLOAT = 121,
+    /** 10-bit blue, 11-bit green, and 11-bit red, unsigned floating-point, packed into a 32-bit word. */
+    B10G11R11_UFLOAT_PACK32 = 122,
+    /** 5-bit shared exponent, 9-bit blue, 9-bit green, and 9-bit red, unsigned floating-point, packed into a 32-bit word. */
+    E5B9G9R9_UFLOAT_PACK32 = 123,
+    /** 16-bit unsigned normalized depth. */
+    D16_UNORM = 124,
+    /** 24-bit unsigned normalized depth packed into a 32-bit word with 8 unused bits. */
+    X8_D24_UNORM_PACK32 = 125,
+    /** 32-bit signed floating-point depth. */
+    D32_SFLOAT = 126,
+    /** 8-bit unsigned integer stencil. */
+    S8_UINT = 127,
+    /** 16-bit unsigned normalized depth and 8-bit unsigned integer stencil. */
+    D16_UNORM_S8_UINT = 128,
+    /** 24-bit unsigned normalized depth and 8-bit unsigned integer stencil. */
+    D24_UNORM_S8_UINT = 129,
+    /** 32-bit signed floating-point depth and 8-bit unsigned integer stencil. */
+    D32_SFLOAT_S8_UINT = 130,
+    /** 4×4 BC1 RGB block compression, unsigned normalized (8 bytes per block). */
+    BC1_RGB_UNORM_BLOCK = 131,
+    /** 4×4 BC1 RGB block compression, sRGB (8 bytes per block). */
+    BC1_RGB_SRGB_BLOCK = 132,
+    /** 4×4 BC1 RGBA block compression with punch-through alpha, unsigned normalized (8 bytes per block). */
+    BC1_RGBA_UNORM_BLOCK = 133,
+    /** 4×4 BC1 RGBA block compression with punch-through alpha, sRGB (8 bytes per block). */
+    BC1_RGBA_SRGB_BLOCK = 134,
+    /** 4×4 BC2 RGBA block compression, unsigned normalized (16 bytes per block). */
+    BC2_UNORM_BLOCK = 135,
+    /** 4×4 BC2 RGBA block compression, sRGB (16 bytes per block). */
+    BC2_SRGB_BLOCK = 136,
+    /** 4×4 BC3 RGBA block compression, unsigned normalized (16 bytes per block). */
+    BC3_UNORM_BLOCK = 137,
+    /** 4×4 BC3 RGBA block compression, sRGB (16 bytes per block). */
+    BC3_SRGB_BLOCK = 138,
+    /** 4×4 BC4 single-channel block compression, unsigned normalized (8 bytes per block). */
+    BC4_UNORM_BLOCK = 139,
+    /** 4×4 BC4 single-channel block compression, signed normalized (8 bytes per block). */
+    BC4_SNORM_BLOCK = 140,
+    /** 4×4 BC5 two-channel block compression, unsigned normalized (16 bytes per block). */
+    BC5_UNORM_BLOCK = 141,
+    /** 4×4 BC5 two-channel block compression, signed normalized (16 bytes per block). */
+    BC5_SNORM_BLOCK = 142,
+    /** 4×4 BC6H HDR block compression, unsigned floating-point (16 bytes per block). */
+    BC6H_UFLOAT_BLOCK = 143,
+    /** 4×4 BC6H HDR block compression, signed floating-point (16 bytes per block). */
+    BC6H_SFLOAT_BLOCK = 144,
+    /** 4×4 BC7 RGBA block compression, unsigned normalized (16 bytes per block). */
+    BC7_UNORM_BLOCK = 145,
+    /** 4×4 BC7 RGBA block compression, sRGB (16 bytes per block). */
+    BC7_SRGB_BLOCK = 146,
+    /** 4×4 ETC2 RGB block compression, unsigned normalized (8 bytes per block). */
+    ETC2_R8G8B8_UNORM_BLOCK = 147,
+    /** 4×4 ETC2 RGB block compression, sRGB (8 bytes per block). */
+    ETC2_R8G8B8_SRGB_BLOCK = 148,
+    /** 4×4 ETC2 RGB block compression with 1-bit alpha, unsigned normalized (8 bytes per block). */
+    ETC2_R8G8B8A1_UNORM_BLOCK = 149,
+    /** 4×4 ETC2 RGB block compression with 1-bit alpha, sRGB (8 bytes per block). */
+    ETC2_R8G8B8A1_SRGB_BLOCK = 150,
+    /** 4×4 ETC2 RGBA block compression, unsigned normalized (16 bytes per block). */
+    ETC2_R8G8B8A8_UNORM_BLOCK = 151,
+    /** 4×4 ETC2 RGBA block compression, sRGB (16 bytes per block). */
+    ETC2_R8G8B8A8_SRGB_BLOCK = 152,
+    /** 4×4 EAC single-channel block compression, unsigned normalized (8 bytes per block). */
+    EAC_R11_UNORM_BLOCK = 153,
+    /** 4×4 EAC single-channel block compression, signed normalized (8 bytes per block). */
+    EAC_R11_SNORM_BLOCK = 154,
+    /** 4×4 EAC two-channel block compression, unsigned normalized (16 bytes per block). */
+    EAC_R11G11_UNORM_BLOCK = 155,
+    /** 4×4 EAC two-channel block compression, signed normalized (16 bytes per block). */
+    EAC_R11G11_SNORM_BLOCK = 156,
+    /** ASTC 4×4 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_4X4_UNORM_BLOCK = 157,
+    /** ASTC 4×4 block compression, sRGB (16 bytes per block). */
+    ASTC_4X4_SRGB_BLOCK = 158,
+    /** ASTC 5×4 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_5X4_UNORM_BLOCK = 159,
+    /** ASTC 5×4 block compression, sRGB (16 bytes per block). */
+    ASTC_5X4_SRGB_BLOCK = 160,
+    /** ASTC 5×5 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_5X5_UNORM_BLOCK = 161,
+    /** ASTC 5×5 block compression, sRGB (16 bytes per block). */
+    ASTC_5X5_SRGB_BLOCK = 162,
+    /** ASTC 6×5 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_6X5_UNORM_BLOCK = 163,
+    /** ASTC 6×5 block compression, sRGB (16 bytes per block). */
+    ASTC_6X5_SRGB_BLOCK = 164,
+    /** ASTC 6×6 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_6X6_UNORM_BLOCK = 165,
+    /** ASTC 6×6 block compression, sRGB (16 bytes per block). */
+    ASTC_6X6_SRGB_BLOCK = 166,
+    /** ASTC 8×5 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_8X5_UNORM_BLOCK = 167,
+    /** ASTC 8×5 block compression, sRGB (16 bytes per block). */
+    ASTC_8X5_SRGB_BLOCK = 168,
+    /** ASTC 8×6 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_8X6_UNORM_BLOCK = 169,
+    /** ASTC 8×6 block compression, sRGB (16 bytes per block). */
+    ASTC_8X6_SRGB_BLOCK = 170,
+    /** ASTC 8×8 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_8X8_UNORM_BLOCK = 171,
+    /** ASTC 8×8 block compression, sRGB (16 bytes per block). */
+    ASTC_8X8_SRGB_BLOCK = 172,
+    /** ASTC 10×5 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_10X5_UNORM_BLOCK = 173,
+    /** ASTC 10×5 block compression, sRGB (16 bytes per block). */
+    ASTC_10X5_SRGB_BLOCK = 174,
+    /** ASTC 10×6 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_10X6_UNORM_BLOCK = 175,
+    /** ASTC 10×6 block compression, sRGB (16 bytes per block). */
+    ASTC_10X6_SRGB_BLOCK = 176,
+    /** ASTC 10×8 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_10X8_UNORM_BLOCK = 177,
+    /** ASTC 10×8 block compression, sRGB (16 bytes per block). */
+    ASTC_10X8_SRGB_BLOCK = 178,
+    /** ASTC 10×10 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_10X10_UNORM_BLOCK = 179,
+    /** ASTC 10×10 block compression, sRGB (16 bytes per block). */
+    ASTC_10X10_SRGB_BLOCK = 180,
+    /** ASTC 12×10 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_12X10_UNORM_BLOCK = 181,
+    /** ASTC 12×10 block compression, sRGB (16 bytes per block). */
+    ASTC_12X10_SRGB_BLOCK = 182,
+    /** ASTC 12×12 block compression, unsigned normalized (16 bytes per block). */
+    ASTC_12X12_UNORM_BLOCK = 183,
+    /** ASTC 12×12 block compression, sRGB (16 bytes per block). */
+    ASTC_12X12_SRGB_BLOCK = 184,
+    /** Packed 4:2:2 format with 8-bit unsigned normalized components in order G, B, G, R. */
+    G8B8G8R8_422_UNORM = 1000156000,
+    /** Packed 4:2:2 format with 8-bit unsigned normalized components in order B, G, R, G. */
+    B8G8R8G8_422_UNORM = 1000156001,
+    /** 4:2:0 format stored as three planes (G, B, and R), 8-bit unsigned normalized samples. */
+    G8_B8_R8_3PLANE_420_UNORM = 1000156002,
+    /** 4:2:0 format stored as two planes (G, and interleaved B and R), 8-bit unsigned normalized samples. */
+    G8_B8R8_2PLANE_420_UNORM = 1000156003,
+    /** 4:2:2 format stored as three planes (G, B, and R), 8-bit unsigned normalized samples. */
+    G8_B8_R8_3PLANE_422_UNORM = 1000156004,
+    /** 4:2:2 format stored as two planes (G, and interleaved B and R), 8-bit unsigned normalized samples. */
+    G8_B8R8_2PLANE_422_UNORM = 1000156005,
+    /** 4:4:4 format stored as three planes (G, B, and R), 8-bit unsigned normalized samples. */
+    G8_B8_R8_3PLANE_444_UNORM = 1000156006,
+    /** red with 10 significant bits and 6 unused bits, unsigned normalized, packed into a 16-bit word. */
+    R10X6_UNORM_PACK16 = 1000156007,
+    /** red and green, each with 10 significant bits and 6 unused bits, unsigned normalized, packed into two 16-bit words. */
+    R10X6G10X6_UNORM_2PACK16 = 1000156008,
+    /** red, green, blue, and alpha, each with 10 significant bits and 6 unused bits, unsigned normalized, packed into four 16-bit words. */
+    R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009,
+    /** Packed 4:2:2 format, unsigned normalized, each component with 10 significant bits and 6 unused bits, component order G, B, G, R. */
+    G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010,
+    /** Packed 4:2:2 format, unsigned normalized, each component with 10 significant bits and 6 unused bits, component order B, G, R, G. */
+    B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011,
+    /** 4:2:0 format stored as three planes (G, B, and R), unsigned normalized samples with 10 significant bits and 6 unused bits. */
+    G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012,
+    /** 4:2:0 format stored as two planes (G, and interleaved B and R), unsigned normalized samples with 10 significant bits and 6 unused bits. */
+    G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013,
+    /** 4:2:2 format stored as three planes (G, B, and R), unsigned normalized samples with 10 significant bits and 6 unused bits. */
+    G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014,
+    /** 4:2:2 format stored as two planes (G, and interleaved B and R), unsigned normalized samples with 10 significant bits and 6 unused bits. */
+    G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015,
+    /** 4:4:4 format stored as three planes (G, B, and R), unsigned normalized samples with 10 significant bits and 6 unused bits. */
+    G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016,
+    /** red with 12 significant bits and 4 unused bits, unsigned normalized, packed into a 16-bit word. */
+    R12X4_UNORM_PACK16 = 1000156017,
+    /** red and green, each with 12 significant bits and 4 unused bits, unsigned normalized, packed into two 16-bit words. */
+    R12X4G12X4_UNORM_2PACK16 = 1000156018,
+    /** red, green, blue, and alpha, each with 12 significant bits and 4 unused bits, unsigned normalized, packed into four 16-bit words. */
+    R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019,
+    /** Packed 4:2:2 format, unsigned normalized, each component with 12 significant bits and 4 unused bits, component order G, B, G, R. */
+    G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020,
+    /** Packed 4:2:2 format, unsigned normalized, each component with 12 significant bits and 4 unused bits, component order B, G, R, G. */
+    B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021,
+    /** 4:2:0 format stored as three planes (G, B, and R), unsigned normalized samples with 12 significant bits and 4 unused bits. */
+    G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022,
+    /** 4:2:0 format stored as two planes (G, and interleaved B and R), unsigned normalized samples with 12 significant bits and 4 unused bits. */
+    G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023,
+    /** 4:2:2 format stored as three planes (G, B, and R), unsigned normalized samples with 12 significant bits and 4 unused bits. */
+    G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024,
+    /** 4:2:2 format stored as two planes (G, and interleaved B and R), unsigned normalized samples with 12 significant bits and 4 unused bits. */
+    G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025,
+    /** 4:4:4 format stored as three planes (G, B, and R), unsigned normalized samples with 12 significant bits and 4 unused bits. */
+    G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026,
+    /** Packed 4:2:2 format with 16-bit unsigned normalized components in order G, B, G, R. */
+    G16B16G16R16_422_UNORM = 1000156027,
+    /** Packed 4:2:2 format with 16-bit unsigned normalized components in order B, G, R, G. */
+    B16G16R16G16_422_UNORM = 1000156028,
+    /** 4:2:0 format stored as three planes (G, B, and R), 16-bit unsigned normalized samples. */
+    G16_B16_R16_3PLANE_420_UNORM = 1000156029,
+    /** 4:2:0 format stored as two planes (G, and interleaved B and R), 16-bit unsigned normalized samples. */
+    G16_B16R16_2PLANE_420_UNORM = 1000156030,
+    /** 4:2:2 format stored as three planes (G, B, and R), 16-bit unsigned normalized samples. */
+    G16_B16_R16_3PLANE_422_UNORM = 1000156031,
+    /** 4:2:2 format stored as two planes (G, and interleaved B and R), 16-bit unsigned normalized samples. */
+    G16_B16R16_2PLANE_422_UNORM = 1000156032,
+    /** 4:4:4 format stored as three planes (G, B, and R), 16-bit unsigned normalized samples. */
+    G16_B16_R16_3PLANE_444_UNORM = 1000156033,
+    /** 4:4:4 format stored as two planes (G, and interleaved B and R), 8-bit unsigned normalized samples. */
+    G8_B8R8_2PLANE_444_UNORM = 1000330000,
+    /** 4:4:4 format stored as two planes (G, and interleaved B and R), unsigned normalized samples with 10 significant bits and 6 unused bits. */
+    G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 = 1000330001,
+    /** 4:4:4 format stored as two planes (G, and interleaved B and R), unsigned normalized samples with 12 significant bits and 4 unused bits. */
+    G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 = 1000330002,
+    /** 4:4:4 format stored as two planes (G, and interleaved B and R), 16-bit unsigned normalized samples. */
+    G16_B16R16_2PLANE_444_UNORM = 1000330003,
+    /** 4-bit alpha, red, green, and blue, unsigned normalized, packed into a 16-bit word. */
+    A4R4G4B4_UNORM_PACK16 = 1000340000,
+    /** 4-bit alpha, blue, green, and red, unsigned normalized, packed into a 16-bit word. */
+    A4B4G4R4_UNORM_PACK16 = 1000340001,
+    /** ASTC 4×4 block compression, signed floating-point (16 bytes per block). */
+    ASTC_4X4_SFLOAT_BLOCK = 1000066000,
+    /** ASTC 5×4 block compression, signed floating-point (16 bytes per block). */
+    ASTC_5X4_SFLOAT_BLOCK = 1000066001,
+    /** ASTC 5×5 block compression, signed floating-point (16 bytes per block). */
+    ASTC_5X5_SFLOAT_BLOCK = 1000066002,
+    /** ASTC 6×5 block compression, signed floating-point (16 bytes per block). */
+    ASTC_6X5_SFLOAT_BLOCK = 1000066003,
+    /** ASTC 6×6 block compression, signed floating-point (16 bytes per block). */
+    ASTC_6X6_SFLOAT_BLOCK = 1000066004,
+    /** ASTC 8×5 block compression, signed floating-point (16 bytes per block). */
+    ASTC_8X5_SFLOAT_BLOCK = 1000066005,
+    /** ASTC 8×6 block compression, signed floating-point (16 bytes per block). */
+    ASTC_8X6_SFLOAT_BLOCK = 1000066006,
+    /** ASTC 8×8 block compression, signed floating-point (16 bytes per block). */
+    ASTC_8X8_SFLOAT_BLOCK = 1000066007,
+    /** ASTC 10×5 block compression, signed floating-point (16 bytes per block). */
+    ASTC_10X5_SFLOAT_BLOCK = 1000066008,
+    /** ASTC 10×6 block compression, signed floating-point (16 bytes per block). */
+    ASTC_10X6_SFLOAT_BLOCK = 1000066009,
+    /** ASTC 10×8 block compression, signed floating-point (16 bytes per block). */
+    ASTC_10X8_SFLOAT_BLOCK = 1000066010,
+    /** ASTC 10×10 block compression, signed floating-point (16 bytes per block). */
+    ASTC_10X10_SFLOAT_BLOCK = 1000066011,
+    /** ASTC 12×10 block compression, signed floating-point (16 bytes per block). */
+    ASTC_12X10_SFLOAT_BLOCK = 1000066012,
+    /** ASTC 12×12 block compression, signed floating-point (16 bytes per block). */
+    ASTC_12X12_SFLOAT_BLOCK = 1000066013,
+    /** 1-bit alpha, 5-bit blue, 5-bit green, and 5-bit red, unsigned normalized, packed into a 16-bit word. */
+    A1B5G5R5_UNORM_PACK16 = 1000470000,
+    /** 8-bit alpha, unsigned normalized. */
+    A8_UNORM = 1000470001,
+    /** PVRTC1 2 bits per pixel, unsigned normalized. */
+    PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
+    /** PVRTC1 4 bits per pixel, unsigned normalized. */
+    PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
+    /** PVRTC2 2 bits per pixel, unsigned normalized. */
+    PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
+    /** PVRTC2 4 bits per pixel, unsigned normalized. */
+    PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
+    /** PVRTC1 2 bits per pixel, sRGB. */
+    PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
+    /** PVRTC1 4 bits per pixel, sRGB. */
+    PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
+    /** PVRTC2 2 bits per pixel, sRGB. */
+    PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
+    /** PVRTC2 4 bits per pixel, sRGB. */
+    PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
+    /** Two 16-bit signed fixed-point components (red and green). Each component has 10 integer bits and 5 fractional bits (NVIDIA). */
+    R16G16_SFIXED5_NV = 1000464000,
+    /** Alias of {@link VkFormat.ASTC_4X4_SFLOAT_BLOCK}. */
+    ASTC_4X4_SFLOAT_BLOCK_EXT = 1000066000,
+    /** Alias of {@link VkFormat.ASTC_5X4_SFLOAT_BLOCK}. */
+    ASTC_5X4_SFLOAT_BLOCK_EXT = 1000066001,
+    /** Alias of {@link VkFormat.ASTC_5X5_SFLOAT_BLOCK}. */
+    ASTC_5X5_SFLOAT_BLOCK_EXT = 1000066002,
+    /** Alias of {@link VkFormat.ASTC_6X5_SFLOAT_BLOCK}. */
+    ASTC_6X5_SFLOAT_BLOCK_EXT = 1000066003,
+    /** Alias of {@link VkFormat.ASTC_6X6_SFLOAT_BLOCK}. */
+    ASTC_6X6_SFLOAT_BLOCK_EXT = 1000066004,
+    /** Alias of {@link VkFormat.ASTC_8X5_SFLOAT_BLOCK}. */
+    ASTC_8X5_SFLOAT_BLOCK_EXT = 1000066005,
+    /** Alias of {@link VkFormat.ASTC_8X6_SFLOAT_BLOCK}. */
+    ASTC_8X6_SFLOAT_BLOCK_EXT = 1000066006,
+    /** Alias of {@link VkFormat.ASTC_8X8_SFLOAT_BLOCK}. */
+    ASTC_8X8_SFLOAT_BLOCK_EXT = 1000066007,
+    /** Alias of {@link VkFormat.ASTC_10X5_SFLOAT_BLOCK}. */
+    ASTC_10X5_SFLOAT_BLOCK_EXT = 1000066008,
+    /** Alias of {@link VkFormat.ASTC_10X6_SFLOAT_BLOCK}. */
+    ASTC_10X6_SFLOAT_BLOCK_EXT = 1000066009,
+    /** Alias of {@link VkFormat.ASTC_10X8_SFLOAT_BLOCK}. */
+    ASTC_10X8_SFLOAT_BLOCK_EXT = 1000066010,
+    /** Alias of {@link VkFormat.ASTC_10X10_SFLOAT_BLOCK}. */
+    ASTC_10X10_SFLOAT_BLOCK_EXT = 1000066011,
+    /** Alias of {@link VkFormat.ASTC_12X10_SFLOAT_BLOCK}. */
+    ASTC_12X10_SFLOAT_BLOCK_EXT = 1000066012,
+    /** Alias of {@link VkFormat.ASTC_12X12_SFLOAT_BLOCK}. */
+    ASTC_12X12_SFLOAT_BLOCK_EXT = 1000066013,
+    /** Alias of {@link VkFormat.G8B8G8R8_422_UNORM}. */
+    G8B8G8R8_422_UNORM_KHR = 1000156000,
+    /** Alias of {@link VkFormat.B8G8R8G8_422_UNORM}. */
+    B8G8R8G8_422_UNORM_KHR = 1000156001,
+    /** Alias of {@link VkFormat.G8_B8_R8_3PLANE_420_UNORM}. */
+    G8_B8_R8_3PLANE_420_UNORM_KHR = 1000156002,
+    /** Alias of {@link VkFormat.G8_B8R8_2PLANE_420_UNORM}. */
+    G8_B8R8_2PLANE_420_UNORM_KHR = 1000156003,
+    /** Alias of {@link VkFormat.G8_B8_R8_3PLANE_422_UNORM}. */
+    G8_B8_R8_3PLANE_422_UNORM_KHR = 1000156004,
+    /** Alias of {@link VkFormat.G8_B8R8_2PLANE_422_UNORM}. */
+    G8_B8R8_2PLANE_422_UNORM_KHR = 1000156005,
+    /** Alias of {@link VkFormat.G8_B8_R8_3PLANE_444_UNORM}. */
+    G8_B8_R8_3PLANE_444_UNORM_KHR = 1000156006,
+    /** Alias of {@link VkFormat.R10X6_UNORM_PACK16}. */
+    R10X6_UNORM_PACK16_KHR = 1000156007,
+    /** Alias of {@link VkFormat.R10X6G10X6_UNORM_2PACK16}. */
+    R10X6G10X6_UNORM_2PACK16_KHR = 1000156008,
+    /** Alias of {@link VkFormat.R10X6G10X6B10X6A10X6_UNORM_4PACK16}. */
+    R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = 1000156009,
+    /** Alias of {@link VkFormat.G10X6B10X6G10X6R10X6_422_UNORM_4PACK16}. */
+    G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = 1000156010,
+    /** Alias of {@link VkFormat.B10X6G10X6R10X6G10X6_422_UNORM_4PACK16}. */
+    B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = 1000156011,
+    /** Alias of {@link VkFormat.G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16}. */
+    G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = 1000156012,
+    /** Alias of {@link VkFormat.G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16}. */
+    G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = 1000156013,
+    /** Alias of {@link VkFormat.G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16}. */
+    G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = 1000156014,
+    /** Alias of {@link VkFormat.G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16}. */
+    G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = 1000156015,
+    /** Alias of {@link VkFormat.G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16}. */
+    G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = 1000156016,
+    /** Alias of {@link VkFormat.R12X4_UNORM_PACK16}. */
+    R12X4_UNORM_PACK16_KHR = 1000156017,
+    /** Alias of {@link VkFormat.R12X4G12X4_UNORM_2PACK16}. */
+    R12X4G12X4_UNORM_2PACK16_KHR = 1000156018,
+    /** Alias of {@link VkFormat.R12X4G12X4B12X4A12X4_UNORM_4PACK16}. */
+    R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = 1000156019,
+    /** Alias of {@link VkFormat.G12X4B12X4G12X4R12X4_422_UNORM_4PACK16}. */
+    G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = 1000156020,
+    /** Alias of {@link VkFormat.B12X4G12X4R12X4G12X4_422_UNORM_4PACK16}. */
+    B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = 1000156021,
+    /** Alias of {@link VkFormat.G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16}. */
+    G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = 1000156022,
+    /** Alias of {@link VkFormat.G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16}. */
+    G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = 1000156023,
+    /** Alias of {@link VkFormat.G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16}. */
+    G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = 1000156024,
+    /** Alias of {@link VkFormat.G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16}. */
+    G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = 1000156025,
+    /** Alias of {@link VkFormat.G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16}. */
+    G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = 1000156026,
+    /** Alias of {@link VkFormat.G16B16G16R16_422_UNORM}. */
+    G16B16G16R16_422_UNORM_KHR = 1000156027,
+    /** Alias of {@link VkFormat.B16G16R16G16_422_UNORM}. */
+    B16G16R16G16_422_UNORM_KHR = 1000156028,
+    /** Alias of {@link VkFormat.G16_B16_R16_3PLANE_420_UNORM}. */
+    G16_B16_R16_3PLANE_420_UNORM_KHR = 1000156029,
+    /** Alias of {@link VkFormat.G16_B16R16_2PLANE_420_UNORM}. */
+    G16_B16R16_2PLANE_420_UNORM_KHR = 1000156030,
+    /** Alias of {@link VkFormat.G16_B16_R16_3PLANE_422_UNORM}. */
+    G16_B16_R16_3PLANE_422_UNORM_KHR = 1000156031,
+    /** Alias of {@link VkFormat.G16_B16R16_2PLANE_422_UNORM}. */
+    G16_B16R16_2PLANE_422_UNORM_KHR = 1000156032,
+    /** Alias of {@link VkFormat.G16_B16_R16_3PLANE_444_UNORM}. */
+    G16_B16_R16_3PLANE_444_UNORM_KHR = 1000156033,
+    /** Alias of {@link VkFormat.G8_B8R8_2PLANE_444_UNORM}. */
+    G8_B8R8_2PLANE_444_UNORM_EXT = 1000330000,
+    /** Alias of {@link VkFormat.G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16}. */
+    G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = 1000330001,
+    /** Alias of {@link VkFormat.G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16}. */
+    G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = 1000330002,
+    /** Alias of {@link VkFormat.G16_B16R16_2PLANE_444_UNORM}. */
+    G16_B16R16_2PLANE_444_UNORM_EXT = 1000330003,
+    /** Alias of {@link VkFormat.A4R4G4B4_UNORM_PACK16}. */
+    A4R4G4B4_UNORM_PACK16_EXT = 1000340000,
+    /** Alias of {@link VkFormat.A4B4G4R4_UNORM_PACK16}. */
+    A4B4G4R4_UNORM_PACK16_EXT = 1000340001,
+    /** Alias of {@link VkFormat.R16G16_SFIXED5_NV}. */
+    R16G16_S10_5_NV = 1000464000,
+    /** Alias of {@link VkFormat.A1B5G5R5_UNORM_PACK16}. */
+    A1B5G5R5_UNORM_PACK16_KHR = 1000470000,
+    /** Alias of {@link VkFormat.A8_UNORM}. */
+    A8_UNORM_KHR = 1000470001,
+    /** Largest enumerator value. Not a texture format. */
+    MAX_ENUM = 2147483647
+}
+
+export { }