zstd.di (saved as .d) generated with dstep from {zstd_source_root_v1.5.2}/lib/zstd.h with some tidying up and fixes. Don't recall if I finished all 'fixing up' though.

zstd.d

module zstd.c.zstd;

// I am leaving comments in in this version so people can see what was done.

// extern (D) string ZSTD_QUOTE(T)(auto ref T str)
// {
//     import std.conv : to;
//     return to!string(str);
// }

extern (C):
@trusted:

// old d package has these the other way round!
alias ZSTD_CCtx = ZSTD_CCtx_s;
alias ZSTD_CDict = ZSTD_CDict_s;
alias ZSTD_CStream = ZSTD_CCtx_s;
alias ZSTD_DCtx = ZSTD_DCtx_s;
alias ZSTD_DDict = ZSTD_DDict_s;
alias ZSTD_DStream = ZSTD_DCtx_s;

//alias ZSTD_EXPAND_AND_QUOTE = ZSTD_QUOTE;

alias ZSTD_inBuffer = ZSTD_inBuffer_s;
alias ZSTD_outBuffer = ZSTD_outBuffer_s;

struct ZSTD_inBuffer_s
{
    const(void)* src;
    size_t size;
    size_t pos;
}

struct ZSTD_outBuffer_s
{
    void* dst;
    size_t size;
    size_t pos;
}

struct ZSTD_bounds
{
    size_t error;
    int lowerBound;
    int upperBound;
}

struct ZSTD_CCtx_s;
struct ZSTD_DCtx_s;
struct ZSTD_CDict_s;
struct ZSTD_DDict_s;

// had issues w/ dmd.
//enum ZSTDLIB_API = ZSTDLIB_VISIBLE;

enum ZSTD_VERSION_MAJOR = 1;
enum ZSTD_VERSION_MINOR = 5;
enum ZSTD_VERSION_RELEASE = 2;
enum ZSTD_VERSION_NUMBER = ZSTD_VERSION_MAJOR * 100 * 100 + ZSTD_VERSION_MINOR * 100 + ZSTD_VERSION_RELEASE;
uint ZSTD_versionNumber ();

// this has to be formatted differently for dmd to like so prolly as 1.5.2 without "" is not a number.
//enum ZSTD_LIB_VERSION = ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE;
//enum ZSTD_LIB_VERSION = "1.5.2";
extern(D) immutable string ZSTD_LIB_VERSION = "1.5.2";
extern(D) immutable string ZSTD_VERSION_STRING = ZSTD_LIB_VERSION;

//enum ZSTD_VERSION_STRING = ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION);
const(char)* ZSTD_versionString ();

enum ZSTD_CLEVEL_DEFAULT = 3;
enum ZSTD_MAGICNUMBER = 0xFD2FB528;
enum ZSTD_MAGIC_DICTIONARY = 0xEC30A437;
enum ZSTD_MAGIC_SKIPPABLE_START = 0x184D2A50;
enum ZSTD_MAGIC_SKIPPABLE_MASK = 0xFFFFFFF0;
enum ZSTD_BLOCKSIZELOG_MAX = 17;
enum ZSTD_BLOCKSIZE_MAX = 1 << ZSTD_BLOCKSIZELOG_MAX;

size_t ZSTD_compress (
    void* dst,
    size_t dstCapacity,
    const(void)* src,
    size_t srcSize,
    int compressionLevel);

size_t ZSTD_decompress (
    void* dst,
    size_t dstCapacity,
    const(void)* src,
    size_t compressedSize);

// dstep , should possibly report it?
// 0ULL is unrecognised token. ULL should be translated into ulong right?
// original was 0ULL -1 and 0ULL -2
enum : ulong { ZSTD_CONTENTSIZE_UNKNOWN = -1, ZSTD_CONTENTSIZE_ERROR = -2 }

ulong ZSTD_getFrameContentSize (const(void)* src, size_t srcSize);
ulong ZSTD_getDecompressedSize (const(void)* src, size_t srcSize);

size_t ZSTD_findFrameCompressedSize (const(void)* src, size_t srcSize);
size_t ZSTD_compressBound (size_t srcSize);

uint ZSTD_isError (size_t code);

const(char)* ZSTD_getErrorName (size_t code);

int ZSTD_minCLevel ();
int ZSTD_maxCLevel ();
int ZSTD_defaultCLevel ();

ZSTD_CCtx* ZSTD_createCCtx ();
size_t ZSTD_freeCCtx (ZSTD_CCtx* cctx);


size_t ZSTD_compressCCtx (
    ZSTD_CCtx* cctx, 
    void* dst, 
    size_t dstCapacity, 
    const(void)* src, 
    size_t srcSize, 
    int compressionLevel);

ZSTD_DCtx* ZSTD_createDCtx ();

size_t ZSTD_freeDCtx (ZSTD_DCtx* dctx);

size_t ZSTD_decompressDCtx (
    ZSTD_DCtx* dctx,
    void* dst,
    size_t dstCapacity,
    const(void)* src,
    size_t srcSize);

enum ZSTD_strategy
{
    ZSTD_fast = 1,
    ZSTD_dfast = 2,
    ZSTD_greedy = 3,
    ZSTD_lazy = 4,
    ZSTD_lazy2 = 5,
    ZSTD_btlazy2 = 6,
    ZSTD_btopt = 7,
    ZSTD_btultra = 8,
    ZSTD_btultra2 = 9
}
enum ZSTD_cParameter
{
    ZSTD_c_compressionLevel = 100,
    ZSTD_c_windowLog = 101,
    ZSTD_c_hashLog = 102,
    ZSTD_c_chainLog = 103,
    ZSTD_c_searchLog = 104,
    ZSTD_c_minMatch = 105,
    ZSTD_c_targetLength = 106,
    ZSTD_c_strategy = 107,
    ZSTD_c_enableLongDistanceMatching = 160,
    ZSTD_c_ldmHashLog = 161,
    ZSTD_c_ldmMinMatch = 162,
    ZSTD_c_ldmBucketSizeLog = 163,
    ZSTD_c_ldmHashRateLog = 164,
    ZSTD_c_contentSizeFlag = 200,
    ZSTD_c_checksumFlag = 201,
    ZSTD_c_dictIDFlag = 202,
    ZSTD_c_nbWorkers = 400,
    ZSTD_c_jobSize = 401,
    ZSTD_c_overlapLog = 402,
    ZSTD_c_experimentalParam1 = 500,
    ZSTD_c_experimentalParam2 = 10,
    ZSTD_c_experimentalParam3 = 1000,
    ZSTD_c_experimentalParam4 = 1001,
    ZSTD_c_experimentalParam5 = 1002,
    ZSTD_c_experimentalParam6 = 1003,
    ZSTD_c_experimentalParam7 = 1004,
    ZSTD_c_experimentalParam8 = 1005,
    ZSTD_c_experimentalParam9 = 1006,
    ZSTD_c_experimentalParam10 = 1007,
    ZSTD_c_experimentalParam11 = 1008,
    ZSTD_c_experimentalParam12 = 1009,
    ZSTD_c_experimentalParam13 = 1010,
    ZSTD_c_experimentalParam14 = 1011,
    ZSTD_c_experimentalParam15 = 1012
}

ZSTD_bounds ZSTD_cParam_getBounds (ZSTD_cParameter cParam);
size_t ZSTD_CCtx_setParameter (ZSTD_CCtx* cctx, ZSTD_cParameter param, int value);
size_t ZSTD_CCtx_setPledgedSrcSize (ZSTD_CCtx* cctx, ulong pledgedSrcSize);

enum ZSTD_ResetDirective
{
    ZSTD_reset_session_only = 1,
    ZSTD_reset_parameters = 2,
    ZSTD_reset_session_and_parameters = 3
}
size_t ZSTD_CCtx_reset (ZSTD_CCtx* cctx, ZSTD_ResetDirective reset);

size_t ZSTD_compress2 (
    ZSTD_CCtx* cctx,
    void* dst,
    size_t dstCapacity,
    const(void)* src,
    size_t srcSize);

enum ZSTD_dParameter
{
    ZSTD_d_windowLogMax = 100,
    ZSTD_d_experimentalParam1 = 1000,
    ZSTD_d_experimentalParam2 = 1001,
    ZSTD_d_experimentalParam3 = 1002,
    ZSTD_d_experimentalParam4 = 1003
}

ZSTD_bounds ZSTD_dParam_getBounds (ZSTD_dParameter dParam);
size_t ZSTD_DCtx_setParameter (ZSTD_DCtx* dctx, ZSTD_dParameter param, int value);
size_t ZSTD_DCtx_reset (ZSTD_DCtx* dctx, ZSTD_ResetDirective reset);

ZSTD_CStream* ZSTD_createCStream ();
size_t ZSTD_freeCStream (ZSTD_CStream* zcs);
enum ZSTD_EndDirective
{
    ZSTD_e_continue = 0,
    ZSTD_e_flush = 1,
    ZSTD_e_end = 2
}

size_t ZSTD_compressStream2 (
    ZSTD_CCtx* cctx,
    ZSTD_outBuffer* output,
    ZSTD_inBuffer* input,
    ZSTD_EndDirective endOp);

size_t ZSTD_CStreamInSize ();
size_t ZSTD_CStreamOutSize ();
size_t ZSTD_initCStream (ZSTD_CStream* zcs, int compressionLevel);
size_t ZSTD_compressStream (ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
size_t ZSTD_flushStream (ZSTD_CStream* zcs, ZSTD_outBuffer* output);
size_t ZSTD_endStream (ZSTD_CStream* zcs, ZSTD_outBuffer* output);
ZSTD_DStream* ZSTD_createDStream ();
size_t ZSTD_freeDStream (ZSTD_DStream* zds);
size_t ZSTD_initDStream (ZSTD_DStream* zds);
size_t ZSTD_decompressStream (ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
size_t ZSTD_DStreamInSize ();
size_t ZSTD_DStreamOutSize ();

size_t ZSTD_compress_usingDict (
    ZSTD_CCtx* ctx,
    void* dst,
    size_t dstCapacity,
    const(void)* src,
    size_t srcSize,
    const(void)* dict,
    size_t dictSize,
    int compressionLevel);
size_t ZSTD_decompress_usingDict (
    ZSTD_DCtx* dctx,
    void* dst,
    size_t dstCapacity,
    const(void)* src,
    size_t srcSize,
    const(void)* dict,
    size_t dictSize);

ZSTD_CDict* ZSTD_createCDict (
    const(void)* dictBuffer,
    size_t dictSize,
    int compressionLevel);
size_t ZSTD_freeCDict (ZSTD_CDict* CDict);
size_t ZSTD_compress_usingCDict (
    ZSTD_CCtx* cctx,
    void* dst,
    size_t dstCapacity,
    const(void)* src,
    size_t srcSize,
    const(ZSTD_CDict)* cdict);

ZSTD_DDict* ZSTD_createDDict (const(void)* dictBuffer, size_t dictSize);

size_t ZSTD_freeDDict (ZSTD_DDict* ddict);

size_t ZSTD_decompress_usingDDict (
    ZSTD_DCtx* dctx,
    void* dst,
    size_t dstCapacity,
    const(void)* src,
    size_t srcSize,
    const(ZSTD_DDict)* ddict);
uint ZSTD_getDictID_fromDict (const(void)* dict, size_t dictSize);
uint ZSTD_getDictID_fromCDict (const(ZSTD_CDict)* cdict);
uint ZSTD_getDictID_fromDDict (const(ZSTD_DDict)* ddict);
uint ZSTD_getDictID_fromFrame (const(void)* src, size_t srcSize);

size_t ZSTD_CCtx_loadDictionary (ZSTD_CCtx* cctx, const(void)* dict, size_t dictSize);
size_t ZSTD_CCtx_refCDict (ZSTD_CCtx* cctx, const(ZSTD_CDict)* cdict);
size_t ZSTD_CCtx_refPrefix (
    ZSTD_CCtx* cctx,
    const(void)* prefix,
    size_t prefixSize);
size_t ZSTD_DCtx_loadDictionary (ZSTD_DCtx* dctx, const(void)* dict, size_t dictSize);
size_t ZSTD_DCtx_refDDict (ZSTD_DCtx* dctx, const(ZSTD_DDict)* ddict);
size_t ZSTD_DCtx_refPrefix (
    ZSTD_DCtx* dctx,
    const(void)* prefix,
    size_t prefixSize);
size_t ZSTD_sizeof_CCtx (const(ZSTD_CCtx)* cctx);
size_t ZSTD_sizeof_DCtx (const(ZSTD_DCtx)* dctx);
size_t ZSTD_sizeof_CStream (const(ZSTD_CStream)* zcs);
size_t ZSTD_sizeof_DStream (const(ZSTD_DStream)* zds);
size_t ZSTD_sizeof_CDict (const(ZSTD_CDict)* cdict);
size_t ZSTD_sizeof_DDict (const(ZSTD_DDict)* ddict);