//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (325)
//--------------------------------------------------------------------------------
pub const DIRECTSOUND_VERSION = @as(u32, 1792);
pub const _FACDS = @as(u32, 2168);
pub const CLSID_DirectSound = Guid.initString("47d4d946-62e8-11cf-93bc-444553540000");
pub const CLSID_DirectSound8 = Guid.initString("3901cc3f-84b5-4fa4-ba35-aa8172b8a09b");
pub const CLSID_DirectSoundCapture = Guid.initString("b0210780-89cd-11d0-af08-00a0c925cd16");
pub const CLSID_DirectSoundCapture8 = Guid.initString("e4bcac13-7f99-4908-9a8e-74e3bf24b6e1");
pub const CLSID_DirectSoundFullDuplex = Guid.initString("fea4300c-7959-4147-b26a-2377b9e7a91d");
pub const DSDEVID_DefaultPlayback = Guid.initString("def00000-9c6d-47ed-aaf1-4dda8f2b5c03");
pub const DSDEVID_DefaultCapture = Guid.initString("def00001-9c6d-47ed-aaf1-4dda8f2b5c03");
pub const DSDEVID_DefaultVoicePlayback = Guid.initString("def00002-9c6d-47ed-aaf1-4dda8f2b5c03");
pub const DSDEVID_DefaultVoiceCapture = Guid.initString("def00003-9c6d-47ed-aaf1-4dda8f2b5c03");
pub const DSFX_LOCHARDWARE = @as(u32, 1);
pub const DSFX_LOCSOFTWARE = @as(u32, 2);
pub const DSCFX_LOCHARDWARE = @as(u32, 1);
pub const DSCFX_LOCSOFTWARE = @as(u32, 2);
pub const DSCFXR_LOCHARDWARE = @as(u32, 16);
pub const DSCFXR_LOCSOFTWARE = @as(u32, 32);
pub const GUID_All_Objects = Guid.initString("aa114de5-c262-4169-a1c8-23d698cc73b5");
pub const KSPROPERTY_SUPPORT_GET = @as(u32, 1);
pub const KSPROPERTY_SUPPORT_SET = @as(u32, 2);
pub const DSFXGARGLE_WAVE_TRIANGLE = @as(u32, 0);
pub const DSFXGARGLE_WAVE_SQUARE = @as(u32, 1);
pub const DSFXGARGLE_RATEHZ_MIN = @as(u32, 1);
pub const DSFXGARGLE_RATEHZ_MAX = @as(u32, 1000);
pub const DSFXCHORUS_WAVE_TRIANGLE = @as(u32, 0);
pub const DSFXCHORUS_WAVE_SIN = @as(u32, 1);
pub const DSFXCHORUS_WETDRYMIX_MIN = @as(f32, 0);
pub const DSFXCHORUS_WETDRYMIX_MAX = @as(f32, 100);
pub const DSFXCHORUS_DEPTH_MIN = @as(f32, 0);
pub const DSFXCHORUS_DEPTH_MAX = @as(f32, 100);
pub const DSFXCHORUS_FEEDBACK_MIN = @as(f32, -99);
pub const DSFXCHORUS_FEEDBACK_MAX = @as(f32, 99);
pub const DSFXCHORUS_FREQUENCY_MIN = @as(f32, 0);
pub const DSFXCHORUS_FREQUENCY_MAX = @as(f32, 10);
pub const DSFXCHORUS_DELAY_MIN = @as(f32, 0);
pub const DSFXCHORUS_DELAY_MAX = @as(f32, 20);
pub const DSFXCHORUS_PHASE_MIN = @as(u32, 0);
pub const DSFXCHORUS_PHASE_MAX = @as(u32, 4);
pub const DSFXCHORUS_PHASE_NEG_180 = @as(u32, 0);
pub const DSFXCHORUS_PHASE_NEG_90 = @as(u32, 1);
pub const DSFXCHORUS_PHASE_ZERO = @as(u32, 2);
pub const DSFXCHORUS_PHASE_90 = @as(u32, 3);
pub const DSFXCHORUS_PHASE_180 = @as(u32, 4);
pub const DSFXFLANGER_WAVE_TRIANGLE = @as(u32, 0);
pub const DSFXFLANGER_WAVE_SIN = @as(u32, 1);
pub const DSFXFLANGER_WETDRYMIX_MIN = @as(f32, 0);
pub const DSFXFLANGER_WETDRYMIX_MAX = @as(f32, 100);
pub const DSFXFLANGER_FREQUENCY_MIN = @as(f32, 0);
pub const DSFXFLANGER_FREQUENCY_MAX = @as(f32, 10);
pub const DSFXFLANGER_DEPTH_MIN = @as(f32, 0);
pub const DSFXFLANGER_DEPTH_MAX = @as(f32, 100);
pub const DSFXFLANGER_PHASE_MIN = @as(u32, 0);
pub const DSFXFLANGER_PHASE_MAX = @as(u32, 4);
pub const DSFXFLANGER_FEEDBACK_MIN = @as(f32, -99);
pub const DSFXFLANGER_FEEDBACK_MAX = @as(f32, 99);
pub const DSFXFLANGER_DELAY_MIN = @as(f32, 0);
pub const DSFXFLANGER_DELAY_MAX = @as(f32, 4);
pub const DSFXFLANGER_PHASE_NEG_180 = @as(u32, 0);
pub const DSFXFLANGER_PHASE_NEG_90 = @as(u32, 1);
pub const DSFXFLANGER_PHASE_ZERO = @as(u32, 2);
pub const DSFXFLANGER_PHASE_90 = @as(u32, 3);
pub const DSFXFLANGER_PHASE_180 = @as(u32, 4);
pub const DSFXECHO_WETDRYMIX_MIN = @as(f32, 0);
pub const DSFXECHO_WETDRYMIX_MAX = @as(f32, 100);
pub const DSFXECHO_FEEDBACK_MIN = @as(f32, 0);
pub const DSFXECHO_FEEDBACK_MAX = @as(f32, 100);
pub const DSFXECHO_LEFTDELAY_MIN = @as(f32, 1);
pub const DSFXECHO_LEFTDELAY_MAX = @as(f32, 2000);
pub const DSFXECHO_RIGHTDELAY_MIN = @as(f32, 1);
pub const DSFXECHO_RIGHTDELAY_MAX = @as(f32, 2000);
pub const DSFXECHO_PANDELAY_MIN = @as(u32, 0);
pub const DSFXECHO_PANDELAY_MAX = @as(u32, 1);
pub const DSFXDISTORTION_GAIN_MIN = @as(f32, -60);
pub const DSFXDISTORTION_GAIN_MAX = @as(f32, 0);
pub const DSFXDISTORTION_EDGE_MIN = @as(f32, 0);
pub const DSFXDISTORTION_EDGE_MAX = @as(f32, 100);
pub const DSFXDISTORTION_POSTEQCENTERFREQUENCY_MIN = @as(f32, 100);
pub const DSFXDISTORTION_POSTEQCENTERFREQUENCY_MAX = @as(f32, 8000);
pub const DSFXDISTORTION_POSTEQBANDWIDTH_MIN = @as(f32, 100);
pub const DSFXDISTORTION_POSTEQBANDWIDTH_MAX = @as(f32, 8000);
pub const DSFXDISTORTION_PRELOWPASSCUTOFF_MIN = @as(f32, 100);
pub const DSFXDISTORTION_PRELOWPASSCUTOFF_MAX = @as(f32, 8000);
pub const DSFXCOMPRESSOR_GAIN_MIN = @as(f32, -60);
pub const DSFXCOMPRESSOR_GAIN_MAX = @as(f32, 60);
pub const DSFXCOMPRESSOR_ATTACK_MIN = @as(f32, 1.0e-02);
pub const DSFXCOMPRESSOR_ATTACK_MAX = @as(f32, 500);
pub const DSFXCOMPRESSOR_RELEASE_MIN = @as(f32, 50);
pub const DSFXCOMPRESSOR_RELEASE_MAX = @as(f32, 3000);
pub const DSFXCOMPRESSOR_THRESHOLD_MIN = @as(f32, -60);
pub const DSFXCOMPRESSOR_THRESHOLD_MAX = @as(f32, 0);
pub const DSFXCOMPRESSOR_RATIO_MIN = @as(f32, 1);
pub const DSFXCOMPRESSOR_RATIO_MAX = @as(f32, 100);
pub const DSFXCOMPRESSOR_PREDELAY_MIN = @as(f32, 0);
pub const DSFXCOMPRESSOR_PREDELAY_MAX = @as(f32, 4);
pub const DSFXPARAMEQ_CENTER_MIN = @as(f32, 80);
pub const DSFXPARAMEQ_CENTER_MAX = @as(f32, 16000);
pub const DSFXPARAMEQ_BANDWIDTH_MIN = @as(f32, 1);
pub const DSFXPARAMEQ_BANDWIDTH_MAX = @as(f32, 36);
pub const DSFXPARAMEQ_GAIN_MIN = @as(f32, -15);
pub const DSFXPARAMEQ_GAIN_MAX = @as(f32, 15);
pub const DSFX_I3DL2REVERB_ROOM_MIN = @as(i32, -10000);
pub const DSFX_I3DL2REVERB_ROOM_MAX = @as(u32, 0);
pub const DSFX_I3DL2REVERB_ROOM_DEFAULT = @as(i32, -1000);
pub const DSFX_I3DL2REVERB_ROOMHF_MIN = @as(i32, -10000);
pub const DSFX_I3DL2REVERB_ROOMHF_MAX = @as(u32, 0);
pub const DSFX_I3DL2REVERB_ROOMHF_DEFAULT = @as(i32, -100);
pub const DSFX_I3DL2REVERB_ROOMROLLOFFFACTOR_MIN = @as(f32, 0);
pub const DSFX_I3DL2REVERB_ROOMROLLOFFFACTOR_MAX = @as(f32, 10);
pub const DSFX_I3DL2REVERB_ROOMROLLOFFFACTOR_DEFAULT = @as(f32, 0);
pub const DSFX_I3DL2REVERB_DECAYTIME_MIN = @as(f32, 1.0e-01);
pub const DSFX_I3DL2REVERB_DECAYTIME_MAX = @as(f32, 20);
pub const DSFX_I3DL2REVERB_DECAYTIME_DEFAULT = @as(f32, 1.49e+00);
pub const DSFX_I3DL2REVERB_DECAYHFRATIO_MIN = @as(f32, 1.0e-01);
pub const DSFX_I3DL2REVERB_DECAYHFRATIO_MAX = @as(f32, 2);
pub const DSFX_I3DL2REVERB_DECAYHFRATIO_DEFAULT = @as(f32, 8.3e-01);
pub const DSFX_I3DL2REVERB_REFLECTIONS_MIN = @as(i32, -10000);
pub const DSFX_I3DL2REVERB_REFLECTIONS_MAX = @as(u32, 1000);
pub const DSFX_I3DL2REVERB_REFLECTIONS_DEFAULT = @as(i32, -2602);
pub const DSFX_I3DL2REVERB_REFLECTIONSDELAY_MIN = @as(f32, 0);
pub const DSFX_I3DL2REVERB_REFLECTIONSDELAY_MAX = @as(f32, 3.0e-01);
pub const DSFX_I3DL2REVERB_REFLECTIONSDELAY_DEFAULT = @as(f32, 7.0e-03);
pub const DSFX_I3DL2REVERB_REVERB_MIN = @as(i32, -10000);
pub const DSFX_I3DL2REVERB_REVERB_MAX = @as(u32, 2000);
pub const DSFX_I3DL2REVERB_REVERB_DEFAULT = @as(u32, 200);
pub const DSFX_I3DL2REVERB_REVERBDELAY_MIN = @as(f32, 0);
pub const DSFX_I3DL2REVERB_REVERBDELAY_MAX = @as(f32, 1.0e-01);
pub const DSFX_I3DL2REVERB_REVERBDELAY_DEFAULT = @as(f32, 1.1e-02);
pub const DSFX_I3DL2REVERB_DIFFUSION_MIN = @as(f32, 0);
pub const DSFX_I3DL2REVERB_DIFFUSION_MAX = @as(f32, 100);
pub const DSFX_I3DL2REVERB_DIFFUSION_DEFAULT = @as(f32, 100);
pub const DSFX_I3DL2REVERB_DENSITY_MIN = @as(f32, 0);
pub const DSFX_I3DL2REVERB_DENSITY_MAX = @as(f32, 100);
pub const DSFX_I3DL2REVERB_DENSITY_DEFAULT = @as(f32, 100);
pub const DSFX_I3DL2REVERB_HFREFERENCE_MIN = @as(f32, 20);
pub const DSFX_I3DL2REVERB_HFREFERENCE_MAX = @as(f32, 20000);
pub const DSFX_I3DL2REVERB_HFREFERENCE_DEFAULT = @as(f32, 5000);
pub const DSFX_I3DL2REVERB_QUALITY_MIN = @as(u32, 0);
pub const DSFX_I3DL2REVERB_QUALITY_MAX = @as(u32, 3);
pub const DSFX_I3DL2REVERB_QUALITY_DEFAULT = @as(u32, 2);
pub const DSFX_WAVESREVERB_INGAIN_MIN = @as(f32, -96);
pub const DSFX_WAVESREVERB_INGAIN_MAX = @as(f32, 0);
pub const DSFX_WAVESREVERB_INGAIN_DEFAULT = @as(f32, 0);
pub const DSFX_WAVESREVERB_REVERBMIX_MIN = @as(f32, -96);
pub const DSFX_WAVESREVERB_REVERBMIX_MAX = @as(f32, 0);
pub const DSFX_WAVESREVERB_REVERBMIX_DEFAULT = @as(f32, 0);
pub const DSFX_WAVESREVERB_REVERBTIME_MIN = @as(f32, 1.0e-03);
pub const DSFX_WAVESREVERB_REVERBTIME_MAX = @as(f32, 3000);
pub const DSFX_WAVESREVERB_REVERBTIME_DEFAULT = @as(f32, 1000);
pub const DSFX_WAVESREVERB_HIGHFREQRTRATIO_MIN = @as(f32, 1.0e-03);
pub const DSFX_WAVESREVERB_HIGHFREQRTRATIO_MAX = @as(f32, 9.99e-01);
pub const DSFX_WAVESREVERB_HIGHFREQRTRATIO_DEFAULT = @as(f32, 1.0e-03);
pub const DSCFX_AEC_MODE_PASS_THROUGH = @as(u32, 0);
pub const DSCFX_AEC_MODE_HALF_DUPLEX = @as(u32, 1);
pub const DSCFX_AEC_MODE_FULL_DUPLEX = @as(u32, 2);
pub const DSCFX_AEC_STATUS_HISTORY_UNINITIALIZED = @as(u32, 0);
pub const DSCFX_AEC_STATUS_HISTORY_CONTINUOUSLY_CONVERGED = @as(u32, 1);
pub const DSCFX_AEC_STATUS_HISTORY_PREVIOUSLY_DIVERGED = @as(u32, 2);
pub const DSCFX_AEC_STATUS_CURRENTLY_CONVERGED = @as(u32, 8);
pub const DS_NO_VIRTUALIZATION = @import("../../zig.zig").typedConst(HRESULT, @as(i32, 142082058));
pub const DSCAPS_PRIMARYMONO = @as(u32, 1);
pub const DSCAPS_PRIMARYSTEREO = @as(u32, 2);
pub const DSCAPS_PRIMARY8BIT = @as(u32, 4);
pub const DSCAPS_PRIMARY16BIT = @as(u32, 8);
pub const DSCAPS_CONTINUOUSRATE = @as(u32, 16);
pub const DSCAPS_EMULDRIVER = @as(u32, 32);
pub const DSCAPS_CERTIFIED = @as(u32, 64);
pub const DSCAPS_SECONDARYMONO = @as(u32, 256);
pub const DSCAPS_SECONDARYSTEREO = @as(u32, 512);
pub const DSCAPS_SECONDARY8BIT = @as(u32, 1024);
pub const DSCAPS_SECONDARY16BIT = @as(u32, 2048);
pub const DSSCL_NORMAL = @as(u32, 1);
pub const DSSCL_PRIORITY = @as(u32, 2);
pub const DSSCL_EXCLUSIVE = @as(u32, 3);
pub const DSSCL_WRITEPRIMARY = @as(u32, 4);
pub const DSSPEAKER_DIRECTOUT = @as(u32, 0);
pub const DSSPEAKER_HEADPHONE = @as(u32, 1);
pub const DSSPEAKER_MONO = @as(u32, 2);
pub const DSSPEAKER_QUAD = @as(u32, 3);
pub const DSSPEAKER_STEREO = @as(u32, 4);
pub const DSSPEAKER_SURROUND = @as(u32, 5);
pub const DSSPEAKER_5POINT1 = @as(u32, 6);
pub const DSSPEAKER_7POINT1 = @as(u32, 7);
pub const DSSPEAKER_7POINT1_SURROUND = @as(u32, 8);
pub const DSSPEAKER_5POINT1_SURROUND = @as(u32, 9);
pub const DSSPEAKER_7POINT1_WIDE = @as(u32, 7);
pub const DSSPEAKER_5POINT1_BACK = @as(u32, 6);
pub const DSSPEAKER_GEOMETRY_MIN = @as(u32, 5);
pub const DSSPEAKER_GEOMETRY_NARROW = @as(u32, 10);
pub const DSSPEAKER_GEOMETRY_WIDE = @as(u32, 20);
pub const DSSPEAKER_GEOMETRY_MAX = @as(u32, 180);
pub const DSBCAPS_PRIMARYBUFFER = @as(u32, 1);
pub const DSBCAPS_STATIC = @as(u32, 2);
pub const DSBCAPS_LOCHARDWARE = @as(u32, 4);
pub const DSBCAPS_LOCSOFTWARE = @as(u32, 8);
pub const DSBCAPS_CTRL3D = @as(u32, 16);
pub const DSBCAPS_CTRLFREQUENCY = @as(u32, 32);
pub const DSBCAPS_CTRLPAN = @as(u32, 64);
pub const DSBCAPS_CTRLVOLUME = @as(u32, 128);
pub const DSBCAPS_CTRLPOSITIONNOTIFY = @as(u32, 256);
pub const DSBCAPS_CTRLFX = @as(u32, 512);
pub const DSBCAPS_STICKYFOCUS = @as(u32, 16384);
pub const DSBCAPS_GLOBALFOCUS = @as(u32, 32768);
pub const DSBCAPS_GETCURRENTPOSITION2 = @as(u32, 65536);
pub const DSBCAPS_MUTE3DATMAXDISTANCE = @as(u32, 131072);
pub const DSBCAPS_LOCDEFER = @as(u32, 262144);
pub const DSBCAPS_TRUEPLAYPOSITION = @as(u32, 524288);
pub const DSBPLAY_LOOPING = @as(u32, 1);
pub const DSBPLAY_LOCHARDWARE = @as(u32, 2);
pub const DSBPLAY_LOCSOFTWARE = @as(u32, 4);
pub const DSBPLAY_TERMINATEBY_TIME = @as(u32, 8);
pub const DSBPLAY_TERMINATEBY_DISTANCE = @as(u64, 16);
pub const DSBPLAY_TERMINATEBY_PRIORITY = @as(u64, 32);
pub const DSBSTATUS_PLAYING = @as(u32, 1);
pub const DSBSTATUS_BUFFERLOST = @as(u32, 2);
pub const DSBSTATUS_LOOPING = @as(u32, 4);
pub const DSBSTATUS_LOCHARDWARE = @as(u32, 8);
pub const DSBSTATUS_LOCSOFTWARE = @as(u32, 16);
pub const DSBSTATUS_TERMINATED = @as(u32, 32);
pub const DSBLOCK_FROMWRITECURSOR = @as(u32, 1);
pub const DSBLOCK_ENTIREBUFFER = @as(u32, 2);
pub const DSBFREQUENCY_ORIGINAL = @as(u32, 0);
pub const DSBFREQUENCY_MIN = @as(u32, 100);
pub const DSBFREQUENCY_MAX = @as(u32, 200000);
pub const DSBPAN_LEFT = @as(i32, -10000);
pub const DSBPAN_CENTER = @as(u32, 0);
pub const DSBPAN_RIGHT = @as(u32, 10000);
pub const DSBVOLUME_MIN = @as(i32, -10000);
pub const DSBVOLUME_MAX = @as(u32, 0);
pub const DSBSIZE_MIN = @as(u32, 4);
pub const DSBSIZE_MAX = @as(u32, 268435455);
pub const DSBSIZE_FX_MIN = @as(u32, 150);
pub const DSBNOTIFICATIONS_MAX = @as(u32, 100000);
pub const DS3DMODE_NORMAL = @as(u32, 0);
pub const DS3DMODE_HEADRELATIVE = @as(u32, 1);
pub const DS3DMODE_DISABLE = @as(u32, 2);
pub const DS3D_IMMEDIATE = @as(u32, 0);
pub const DS3D_DEFERRED = @as(u32, 1);
pub const DS3D_DEFAULTDISTANCEFACTOR = @as(f32, 1);
pub const DS3D_MINROLLOFFFACTOR = @as(f32, 0);
pub const DS3D_MAXROLLOFFFACTOR = @as(f32, 10);
pub const DS3D_DEFAULTROLLOFFFACTOR = @as(f32, 1);
pub const DS3D_MINDOPPLERFACTOR = @as(f32, 0);
pub const DS3D_MAXDOPPLERFACTOR = @as(f32, 10);
pub const DS3D_DEFAULTDOPPLERFACTOR = @as(f32, 1);
pub const DS3D_DEFAULTMINDISTANCE = @as(f32, 1);
pub const DS3D_DEFAULTMAXDISTANCE = @as(f32, 1.0e+09);
pub const DS3D_MINCONEANGLE = @as(u32, 0);
pub const DS3D_MAXCONEANGLE = @as(u32, 360);
pub const DS3D_DEFAULTCONEANGLE = @as(u32, 360);
pub const DS3D_DEFAULTCONEOUTSIDEVOLUME = @as(u32, 0);
pub const DSCCAPS_EMULDRIVER = @as(u32, 32);
pub const DSCCAPS_CERTIFIED = @as(u32, 64);
pub const DSCCAPS_MULTIPLECAPTURE = @as(u32, 1);
pub const DSCBCAPS_WAVEMAPPED = @as(u32, 2147483648);
pub const DSCBCAPS_CTRLFX = @as(u32, 512);
pub const DSCBLOCK_ENTIREBUFFER = @as(u32, 1);
pub const DSCBSTATUS_CAPTURING = @as(u32, 1);
pub const DSCBSTATUS_LOOPING = @as(u32, 2);
pub const DSCBSTART_LOOPING = @as(u32, 1);
pub const DSBPN_OFFSETSTOP = @as(u32, 4294967295);
pub const DS_CERTIFIED = @as(u32, 0);
pub const DS_UNCERTIFIED = @as(u32, 1);
pub const DS3DALG_NO_VIRTUALIZATION = Guid.initString("c241333f-1c1b-11d2-94f5-00c04fc28aca");
pub const DS3DALG_HRTF_FULL = Guid.initString("c2413340-1c1b-11d2-94f5-00c04fc28aca");
pub const DS3DALG_HRTF_LIGHT = Guid.initString("c2413342-1c1b-11d2-94f5-00c04fc28aca");
pub const GUID_DSFX_STANDARD_GARGLE = Guid.initString("dafd8210-5711-4b91-9fe3-f75b7ae279bf");
pub const GUID_DSFX_STANDARD_CHORUS = Guid.initString("efe6629c-81f7-4281-bd91-c9d604a95af6");
pub const GUID_DSFX_STANDARD_FLANGER = Guid.initString("efca3d92-dfd8-4672-a603-7420894bad98");
pub const GUID_DSFX_STANDARD_ECHO = Guid.initString("ef3e932c-d40b-4f51-8ccf-3f98f1b29d5d");
pub const GUID_DSFX_STANDARD_DISTORTION = Guid.initString("ef114c90-cd1d-484e-96e5-09cfaf912a21");
pub const GUID_DSFX_STANDARD_COMPRESSOR = Guid.initString("ef011f79-4000-406d-87af-bffb3fc39d57");
pub const GUID_DSFX_STANDARD_PARAMEQ = Guid.initString("120ced89-3bf4-4173-a132-3cb406cf3231");
pub const GUID_DSFX_STANDARD_I3DL2REVERB = Guid.initString("ef985e71-d5c7-42d4-ba4d-2d073e2e96f4");
pub const GUID_DSFX_WAVES_REVERB = Guid.initString("87fc0268-9a55-4360-95aa-004a1d9de26c");
pub const GUID_DSCFX_CLASS_AEC = Guid.initString("bf963d80-c559-11d0-8a2b-00a0c9255ac1");
pub const GUID_DSCFX_MS_AEC = Guid.initString("cdebb919-379a-488a-8765-f53cfd36de40");
pub const GUID_DSCFX_SYSTEM_AEC = Guid.initString("1c22c56d-9879-4f5b-a389-27996ddc2810");
pub const GUID_DSCFX_CLASS_NS = Guid.initString("e07f903f-62fd-4e60-8cdd-dea7236665b5");
pub const GUID_DSCFX_MS_NS = Guid.initString("11c5c73b-66e9-4ba1-a0ba-e814c6eed92d");
pub const GUID_DSCFX_SYSTEM_NS = Guid.initString("5ab0882e-7274-4516-877d-4eee99ba4fd0");
pub const DSFXR_PRESENT = @as(i32, 0);
pub const DSFXR_LOCHARDWARE = @as(i32, 1);
pub const DSFXR_LOCSOFTWARE = @as(i32, 2);
pub const DSFXR_UNALLOCATED = @as(i32, 3);
pub const DSFXR_FAILED = @as(i32, 4);
pub const DSFXR_UNKNOWN = @as(i32, 5);
pub const DSFXR_SENDLOOP = @as(i32, 6);
pub const DSFX_I3DL2_MATERIAL_PRESET_SINGLEWINDOW = @as(i32, 0);
pub const DSFX_I3DL2_MATERIAL_PRESET_DOUBLEWINDOW = @as(i32, 1);
pub const DSFX_I3DL2_MATERIAL_PRESET_THINDOOR = @as(i32, 2);
pub const DSFX_I3DL2_MATERIAL_PRESET_THICKDOOR = @as(i32, 3);
pub const DSFX_I3DL2_MATERIAL_PRESET_WOODWALL = @as(i32, 4);
pub const DSFX_I3DL2_MATERIAL_PRESET_BRICKWALL = @as(i32, 5);
pub const DSFX_I3DL2_MATERIAL_PRESET_STONEWALL = @as(i32, 6);
pub const DSFX_I3DL2_MATERIAL_PRESET_CURTAIN = @as(i32, 7);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_DEFAULT = @as(i32, 0);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_GENERIC = @as(i32, 1);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_PADDEDCELL = @as(i32, 2);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_ROOM = @as(i32, 3);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_BATHROOM = @as(i32, 4);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_LIVINGROOM = @as(i32, 5);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_STONEROOM = @as(i32, 6);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_AUDITORIUM = @as(i32, 7);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_CONCERTHALL = @as(i32, 8);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_CAVE = @as(i32, 9);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_ARENA = @as(i32, 10);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_HANGAR = @as(i32, 11);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_CARPETEDHALLWAY = @as(i32, 12);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_HALLWAY = @as(i32, 13);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_STONECORRIDOR = @as(i32, 14);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_ALLEY = @as(i32, 15);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_FOREST = @as(i32, 16);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_CITY = @as(i32, 17);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_MOUNTAINS = @as(i32, 18);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_QUARRY = @as(i32, 19);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_PLAIN = @as(i32, 20);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_PARKINGLOT = @as(i32, 21);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_SEWERPIPE = @as(i32, 22);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_UNDERWATER = @as(i32, 23);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_SMALLROOM = @as(i32, 24);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_MEDIUMROOM = @as(i32, 25);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_LARGEROOM = @as(i32, 26);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_MEDIUMHALL = @as(i32, 27);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_LARGEHALL = @as(i32, 28);
pub const DSFX_I3DL2_ENVIRONMENT_PRESET_PLATE = @as(i32, 29);

//--------------------------------------------------------------------------------
// Section: Types (48)
//--------------------------------------------------------------------------------
pub const DSCAPS = extern struct {
    dwSize: u32,
    dwFlags: u32,
    dwMinSecondarySampleRate: u32,
    dwMaxSecondarySampleRate: u32,
    dwPrimaryBuffers: u32,
    dwMaxHwMixingAllBuffers: u32,
    dwMaxHwMixingStaticBuffers: u32,
    dwMaxHwMixingStreamingBuffers: u32,
    dwFreeHwMixingAllBuffers: u32,
    dwFreeHwMixingStaticBuffers: u32,
    dwFreeHwMixingStreamingBuffers: u32,
    dwMaxHw3DAllBuffers: u32,
    dwMaxHw3DStaticBuffers: u32,
    dwMaxHw3DStreamingBuffers: u32,
    dwFreeHw3DAllBuffers: u32,
    dwFreeHw3DStaticBuffers: u32,
    dwFreeHw3DStreamingBuffers: u32,
    dwTotalHwMemBytes: u32,
    dwFreeHwMemBytes: u32,
    dwMaxContigFreeHwMemBytes: u32,
    dwUnlockTransferRateHwBuffers: u32,
    dwPlayCpuOverheadSwBuffers: u32,
    dwReserved1: u32,
    dwReserved2: u32,
};

pub const DSBCAPS = extern struct {
    dwSize: u32,
    dwFlags: u32,
    dwBufferBytes: u32,
    dwUnlockTransferRate: u32,
    dwPlayCpuOverhead: u32,
};

pub const DSEFFECTDESC = extern struct {
    dwSize: u32,
    dwFlags: u32,
    guidDSFXClass: Guid,
    dwReserved1: usize,
    dwReserved2: usize,
};

pub const DSCEFFECTDESC = extern struct {
    dwSize: u32,
    dwFlags: u32,
    guidDSCFXClass: Guid,
    guidDSCFXInstance: Guid,
    dwReserved1: u32,
    dwReserved2: u32,
};

pub const DSBUFFERDESC = extern struct {
    dwSize: u32,
    dwFlags: u32,
    dwBufferBytes: u32,
    dwReserved: u32,
    lpwfxFormat: ?*WAVEFORMATEX,
    guid3DAlgorithm: Guid,
};

pub const DSBUFFERDESC1 = extern struct {
    dwSize: u32,
    dwFlags: u32,
    dwBufferBytes: u32,
    dwReserved: u32,
    lpwfxFormat: ?*WAVEFORMATEX,
};

pub const DS3DBUFFER = extern struct {
    dwSize: u32,
    vPosition: D3DVECTOR,
    vVelocity: D3DVECTOR,
    dwInsideConeAngle: u32,
    dwOutsideConeAngle: u32,
    vConeOrientation: D3DVECTOR,
    lConeOutsideVolume: i32,
    flMinDistance: f32,
    flMaxDistance: f32,
    dwMode: u32,
};

pub const DS3DLISTENER = extern struct {
    dwSize: u32,
    vPosition: D3DVECTOR,
    vVelocity: D3DVECTOR,
    vOrientFront: D3DVECTOR,
    vOrientTop: D3DVECTOR,
    flDistanceFactor: f32,
    flRolloffFactor: f32,
    flDopplerFactor: f32,
};

pub const DSCCAPS = extern struct {
    dwSize: u32,
    dwFlags: u32,
    dwFormats: u32,
    dwChannels: u32,
};

pub const DSCBUFFERDESC1 = extern struct {
    dwSize: u32,
    dwFlags: u32,
    dwBufferBytes: u32,
    dwReserved: u32,
    lpwfxFormat: ?*WAVEFORMATEX,
};

pub const DSCBUFFERDESC = extern struct {
    dwSize: u32,
    dwFlags: u32,
    dwBufferBytes: u32,
    dwReserved: u32,
    lpwfxFormat: ?*WAVEFORMATEX,
    dwFXCount: u32,
    lpDSCFXDesc: ?*DSCEFFECTDESC,
};

pub const DSCBCAPS = extern struct {
    dwSize: u32,
    dwFlags: u32,
    dwBufferBytes: u32,
    dwReserved: u32,
};

pub const DSBPOSITIONNOTIFY = extern struct {
    dwOffset: u32,
    hEventNotify: ?HANDLE,
};

pub const LPDSENUMCALLBACKA = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?*Guid,
        param1: ?[*:0]const u8,
        param2: ?[*:0]const u8,
        param3: ?*anyopaque,
    ) callconv(@import("std").os.windows.WINAPI) BOOL,
    else => *const fn (
        param0: ?*Guid,
        param1: ?[*:0]const u8,
        param2: ?[*:0]const u8,
        param3: ?*anyopaque,
    ) callconv(@import("std").os.windows.WINAPI) BOOL,
};

pub const LPDSENUMCALLBACKW = switch (@import("builtin").zig_backend) {
    .stage1 => fn (
        param0: ?*Guid,
        param1: ?[*:0]const u16,
        param2: ?[*:0]const u16,
        param3: ?*anyopaque,
    ) callconv(@import("std").os.windows.WINAPI) BOOL,
    else => *const fn (
        param0: ?*Guid,
        param1: ?[*:0]const u16,
        param2: ?[*:0]const u16,
        param3: ?*anyopaque,
    ) callconv(@import("std").os.windows.WINAPI) BOOL,
};

const IID_IDirectSound_Value = Guid.initString("279afa83-4981-11ce-a521-0020af0be560");
pub const IID_IDirectSound = &IID_IDirectSound_Value;
pub const IDirectSound = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        CreateSoundBuffer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound,
                pcDSBufferDesc: ?*DSBUFFERDESC,
                ppDSBuffer: ?*?*IDirectSoundBuffer,
                pUnkOuter: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound,
                pcDSBufferDesc: ?*DSBUFFERDESC,
                ppDSBuffer: ?*?*IDirectSoundBuffer,
                pUnkOuter: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCaps: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound,
                pDSCaps: ?*DSCAPS,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound,
                pDSCaps: ?*DSCAPS,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        DuplicateSoundBuffer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound,
                pDSBufferOriginal: ?*IDirectSoundBuffer,
                ppDSBufferDuplicate: ?*?*IDirectSoundBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound,
                pDSBufferOriginal: ?*IDirectSoundBuffer,
                ppDSBufferDuplicate: ?*?*IDirectSoundBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetCooperativeLevel: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound,
                hwnd: ?HWND,
                dwLevel: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound,
                hwnd: ?HWND,
                dwLevel: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Compact: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetSpeakerConfig: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound,
                pdwSpeakerConfig: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound,
                pdwSpeakerConfig: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetSpeakerConfig: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound,
                dwSpeakerConfig: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound,
                dwSpeakerConfig: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Initialize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound,
                pcGuidDevice: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound,
                pcGuidDevice: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound_CreateSoundBuffer(self: *const T, pcDSBufferDesc: ?*DSBUFFERDESC, ppDSBuffer: ?*?*IDirectSoundBuffer, pUnkOuter: ?*IUnknown) HRESULT {
                return @as(*const IDirectSound.VTable, @ptrCast(self.vtable)).CreateSoundBuffer(@as(*const IDirectSound, @ptrCast(self)), pcDSBufferDesc, ppDSBuffer, pUnkOuter);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound_GetCaps(self: *const T, pDSCaps: ?*DSCAPS) HRESULT {
                return @as(*const IDirectSound.VTable, @ptrCast(self.vtable)).GetCaps(@as(*const IDirectSound, @ptrCast(self)), pDSCaps);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound_DuplicateSoundBuffer(self: *const T, pDSBufferOriginal: ?*IDirectSoundBuffer, ppDSBufferDuplicate: ?*?*IDirectSoundBuffer) HRESULT {
                return @as(*const IDirectSound.VTable, @ptrCast(self.vtable)).DuplicateSoundBuffer(@as(*const IDirectSound, @ptrCast(self)), pDSBufferOriginal, ppDSBufferDuplicate);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound_SetCooperativeLevel(self: *const T, hwnd: ?HWND, dwLevel: u32) HRESULT {
                return @as(*const IDirectSound.VTable, @ptrCast(self.vtable)).SetCooperativeLevel(@as(*const IDirectSound, @ptrCast(self)), hwnd, dwLevel);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound_Compact(self: *const T) HRESULT {
                return @as(*const IDirectSound.VTable, @ptrCast(self.vtable)).Compact(@as(*const IDirectSound, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound_GetSpeakerConfig(self: *const T, pdwSpeakerConfig: ?*u32) HRESULT {
                return @as(*const IDirectSound.VTable, @ptrCast(self.vtable)).GetSpeakerConfig(@as(*const IDirectSound, @ptrCast(self)), pdwSpeakerConfig);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound_SetSpeakerConfig(self: *const T, dwSpeakerConfig: u32) HRESULT {
                return @as(*const IDirectSound.VTable, @ptrCast(self.vtable)).SetSpeakerConfig(@as(*const IDirectSound, @ptrCast(self)), dwSpeakerConfig);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound_Initialize(self: *const T, pcGuidDevice: ?*const Guid) HRESULT {
                return @as(*const IDirectSound.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IDirectSound, @ptrCast(self)), pcGuidDevice);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDirectSound8_Value = Guid.initString("c50a7e93-f395-4834-9ef6-7fa99de50966");
pub const IID_IDirectSound8 = &IID_IDirectSound8_Value;
pub const IDirectSound8 = extern struct {
    pub const VTable = extern struct {
        base: IDirectSound.VTable,
        VerifyCertification: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound8,
                pdwCertified: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound8,
                pdwCertified: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDirectSound.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound8_VerifyCertification(self: *const T, pdwCertified: ?*u32) HRESULT {
                return @as(*const IDirectSound8.VTable, @ptrCast(self.vtable)).VerifyCertification(@as(*const IDirectSound8, @ptrCast(self)), pdwCertified);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDirectSoundBuffer_Value = Guid.initString("279afa85-4981-11ce-a521-0020af0be560");
pub const IID_IDirectSoundBuffer = &IID_IDirectSoundBuffer_Value;
pub const IDirectSoundBuffer = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetCaps: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                pDSBufferCaps: ?*DSBCAPS,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                pDSBufferCaps: ?*DSBCAPS,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCurrentPosition: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                pdwCurrentPlayCursor: ?*u32,
                pdwCurrentWriteCursor: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                pdwCurrentPlayCursor: ?*u32,
                pdwCurrentWriteCursor: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFormat: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                // TODO: what to do with BytesParamIndex 1?
                pwfxFormat: ?*WAVEFORMATEX,
                dwSizeAllocated: u32,
                pdwSizeWritten: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                // TODO: what to do with BytesParamIndex 1?
                pwfxFormat: ?*WAVEFORMATEX,
                dwSizeAllocated: u32,
                pdwSizeWritten: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetVolume: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                plVolume: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                plVolume: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPan: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                plPan: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                plPan: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFrequency: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                pdwFrequency: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                pdwFrequency: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetStatus: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                pdwStatus: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                pdwStatus: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Initialize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                pDirectSound: ?*IDirectSound,
                pcDSBufferDesc: ?*DSBUFFERDESC,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                pDirectSound: ?*IDirectSound,
                pcDSBufferDesc: ?*DSBUFFERDESC,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Lock: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                dwOffset: u32,
                dwBytes: u32,
                ppvAudioPtr1: ?*?*anyopaque,
                pdwAudioBytes1: ?*u32,
                ppvAudioPtr2: ?*?*anyopaque,
                pdwAudioBytes2: ?*u32,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                dwOffset: u32,
                dwBytes: u32,
                ppvAudioPtr1: ?*?*anyopaque,
                pdwAudioBytes1: ?*u32,
                ppvAudioPtr2: ?*?*anyopaque,
                pdwAudioBytes2: ?*u32,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Play: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                dwReserved1: u32,
                dwPriority: u32,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                dwReserved1: u32,
                dwPriority: u32,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetCurrentPosition: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                dwNewPosition: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                dwNewPosition: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetFormat: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                pcfxFormat: ?*WAVEFORMATEX,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                pcfxFormat: ?*WAVEFORMATEX,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetVolume: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                lVolume: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                lVolume: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetPan: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                lPan: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                lPan: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetFrequency: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                dwFrequency: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                dwFrequency: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Stop: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Unlock: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
                // TODO: what to do with BytesParamIndex 1?
                pvAudioPtr1: ?*anyopaque,
                dwAudioBytes1: u32,
                // TODO: what to do with BytesParamIndex 3?
                pvAudioPtr2: ?*anyopaque,
                dwAudioBytes2: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
                // TODO: what to do with BytesParamIndex 1?
                pvAudioPtr1: ?*anyopaque,
                dwAudioBytes1: u32,
                // TODO: what to do with BytesParamIndex 3?
                pvAudioPtr2: ?*anyopaque,
                dwAudioBytes2: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Restore: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_GetCaps(self: *const T, pDSBufferCaps: ?*DSBCAPS) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).GetCaps(@as(*const IDirectSoundBuffer, @ptrCast(self)), pDSBufferCaps);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_GetCurrentPosition(self: *const T, pdwCurrentPlayCursor: ?*u32, pdwCurrentWriteCursor: ?*u32) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).GetCurrentPosition(@as(*const IDirectSoundBuffer, @ptrCast(self)), pdwCurrentPlayCursor, pdwCurrentWriteCursor);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_GetFormat(self: *const T, pwfxFormat: ?*WAVEFORMATEX, dwSizeAllocated: u32, pdwSizeWritten: ?*u32) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).GetFormat(@as(*const IDirectSoundBuffer, @ptrCast(self)), pwfxFormat, dwSizeAllocated, pdwSizeWritten);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_GetVolume(self: *const T, plVolume: ?*i32) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).GetVolume(@as(*const IDirectSoundBuffer, @ptrCast(self)), plVolume);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_GetPan(self: *const T, plPan: ?*i32) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).GetPan(@as(*const IDirectSoundBuffer, @ptrCast(self)), plPan);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_GetFrequency(self: *const T, pdwFrequency: ?*u32) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).GetFrequency(@as(*const IDirectSoundBuffer, @ptrCast(self)), pdwFrequency);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_GetStatus(self: *const T, pdwStatus: ?*u32) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).GetStatus(@as(*const IDirectSoundBuffer, @ptrCast(self)), pdwStatus);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_Initialize(self: *const T, pDirectSound: ?*IDirectSound, pcDSBufferDesc: ?*DSBUFFERDESC) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IDirectSoundBuffer, @ptrCast(self)), pDirectSound, pcDSBufferDesc);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_Lock(self: *const T, dwOffset: u32, dwBytes: u32, ppvAudioPtr1: ?*?*anyopaque, pdwAudioBytes1: ?*u32, ppvAudioPtr2: ?*?*anyopaque, pdwAudioBytes2: ?*u32, dwFlags: u32) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).Lock(@as(*const IDirectSoundBuffer, @ptrCast(self)), dwOffset, dwBytes, ppvAudioPtr1, pdwAudioBytes1, ppvAudioPtr2, pdwAudioBytes2, dwFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_Play(self: *const T, dwReserved1: u32, dwPriority: u32, dwFlags: u32) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).Play(@as(*const IDirectSoundBuffer, @ptrCast(self)), dwReserved1, dwPriority, dwFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_SetCurrentPosition(self: *const T, dwNewPosition: u32) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).SetCurrentPosition(@as(*const IDirectSoundBuffer, @ptrCast(self)), dwNewPosition);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_SetFormat(self: *const T, pcfxFormat: ?*WAVEFORMATEX) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).SetFormat(@as(*const IDirectSoundBuffer, @ptrCast(self)), pcfxFormat);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_SetVolume(self: *const T, lVolume: i32) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).SetVolume(@as(*const IDirectSoundBuffer, @ptrCast(self)), lVolume);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_SetPan(self: *const T, lPan: i32) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).SetPan(@as(*const IDirectSoundBuffer, @ptrCast(self)), lPan);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_SetFrequency(self: *const T, dwFrequency: u32) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).SetFrequency(@as(*const IDirectSoundBuffer, @ptrCast(self)), dwFrequency);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_Stop(self: *const T) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).Stop(@as(*const IDirectSoundBuffer, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_Unlock(self: *const T, pvAudioPtr1: ?*anyopaque, dwAudioBytes1: u32, pvAudioPtr2: ?*anyopaque, dwAudioBytes2: u32) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).Unlock(@as(*const IDirectSoundBuffer, @ptrCast(self)), pvAudioPtr1, dwAudioBytes1, pvAudioPtr2, dwAudioBytes2);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer_Restore(self: *const T) HRESULT {
                return @as(*const IDirectSoundBuffer.VTable, @ptrCast(self.vtable)).Restore(@as(*const IDirectSoundBuffer, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDirectSoundBuffer8_Value = Guid.initString("6825a449-7524-4d82-920f-50e36ab3ab1e");
pub const IID_IDirectSoundBuffer8 = &IID_IDirectSoundBuffer8_Value;
pub const IDirectSoundBuffer8 = extern struct {
    pub const VTable = extern struct {
        base: IDirectSoundBuffer.VTable,
        SetFX: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer8,
                dwEffectsCount: u32,
                pDSFXDesc: ?[*]DSEFFECTDESC,
                pdwResultCodes: ?[*]u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer8,
                dwEffectsCount: u32,
                pDSFXDesc: ?[*]DSEFFECTDESC,
                pdwResultCodes: ?[*]u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        AcquireResources: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer8,
                dwFlags: u32,
                dwEffectsCount: u32,
                pdwResultCodes: [*]u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer8,
                dwFlags: u32,
                dwEffectsCount: u32,
                pdwResultCodes: [*]u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetObjectInPath: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundBuffer8,
                rguidObject: ?*const Guid,
                dwIndex: u32,
                rguidInterface: ?*const Guid,
                ppObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundBuffer8,
                rguidObject: ?*const Guid,
                dwIndex: u32,
                rguidInterface: ?*const Guid,
                ppObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDirectSoundBuffer.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer8_SetFX(self: *const T, dwEffectsCount: u32, pDSFXDesc: ?[*]DSEFFECTDESC, pdwResultCodes: ?[*]u32) HRESULT {
                return @as(*const IDirectSoundBuffer8.VTable, @ptrCast(self.vtable)).SetFX(@as(*const IDirectSoundBuffer8, @ptrCast(self)), dwEffectsCount, pDSFXDesc, pdwResultCodes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer8_AcquireResources(self: *const T, dwFlags: u32, dwEffectsCount: u32, pdwResultCodes: [*]u32) HRESULT {
                return @as(*const IDirectSoundBuffer8.VTable, @ptrCast(self.vtable)).AcquireResources(@as(*const IDirectSoundBuffer8, @ptrCast(self)), dwFlags, dwEffectsCount, pdwResultCodes);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundBuffer8_GetObjectInPath(self: *const T, rguidObject: ?*const Guid, dwIndex: u32, rguidInterface: ?*const Guid, ppObject: ?*?*anyopaque) HRESULT {
                return @as(*const IDirectSoundBuffer8.VTable, @ptrCast(self.vtable)).GetObjectInPath(@as(*const IDirectSoundBuffer8, @ptrCast(self)), rguidObject, dwIndex, rguidInterface, ppObject);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDirectSound3DListener_Value = Guid.initString("279afa84-4981-11ce-a521-0020af0be560");
pub const IID_IDirectSound3DListener = &IID_IDirectSound3DListener_Value;
pub const IDirectSound3DListener = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                pListener: ?*DS3DLISTENER,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                pListener: ?*DS3DLISTENER,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDistanceFactor: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                pflDistanceFactor: ?*f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                pflDistanceFactor: ?*f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetDopplerFactor: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                pflDopplerFactor: ?*f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                pflDopplerFactor: ?*f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetOrientation: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                pvOrientFront: ?*D3DVECTOR,
                pvOrientTop: ?*D3DVECTOR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                pvOrientFront: ?*D3DVECTOR,
                pvOrientTop: ?*D3DVECTOR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPosition: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                pvPosition: ?*D3DVECTOR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                pvPosition: ?*D3DVECTOR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetRolloffFactor: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                pflRolloffFactor: ?*f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                pflRolloffFactor: ?*f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetVelocity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                pvVelocity: ?*D3DVECTOR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                pvVelocity: ?*D3DVECTOR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                pcListener: ?*DS3DLISTENER,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                pcListener: ?*DS3DLISTENER,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetDistanceFactor: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                flDistanceFactor: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                flDistanceFactor: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetDopplerFactor: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                flDopplerFactor: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                flDopplerFactor: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetOrientation: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                xFront: f32,
                yFront: f32,
                zFront: f32,
                xTop: f32,
                yTop: f32,
                zTop: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                xFront: f32,
                yFront: f32,
                zFront: f32,
                xTop: f32,
                yTop: f32,
                zTop: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetPosition: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                x: f32,
                y: f32,
                z: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                x: f32,
                y: f32,
                z: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetRolloffFactor: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                flRolloffFactor: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                flRolloffFactor: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetVelocity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
                x: f32,
                y: f32,
                z: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
                x: f32,
                y: f32,
                z: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        CommitDeferredSettings: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DListener,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DListener,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_GetAllParameters(self: *const T, pListener: ?*DS3DLISTENER) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).GetAllParameters(@as(*const IDirectSound3DListener, @ptrCast(self)), pListener);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_GetDistanceFactor(self: *const T, pflDistanceFactor: ?*f32) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).GetDistanceFactor(@as(*const IDirectSound3DListener, @ptrCast(self)), pflDistanceFactor);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_GetDopplerFactor(self: *const T, pflDopplerFactor: ?*f32) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).GetDopplerFactor(@as(*const IDirectSound3DListener, @ptrCast(self)), pflDopplerFactor);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_GetOrientation(self: *const T, pvOrientFront: ?*D3DVECTOR, pvOrientTop: ?*D3DVECTOR) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).GetOrientation(@as(*const IDirectSound3DListener, @ptrCast(self)), pvOrientFront, pvOrientTop);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_GetPosition(self: *const T, pvPosition: ?*D3DVECTOR) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).GetPosition(@as(*const IDirectSound3DListener, @ptrCast(self)), pvPosition);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_GetRolloffFactor(self: *const T, pflRolloffFactor: ?*f32) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).GetRolloffFactor(@as(*const IDirectSound3DListener, @ptrCast(self)), pflRolloffFactor);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_GetVelocity(self: *const T, pvVelocity: ?*D3DVECTOR) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).GetVelocity(@as(*const IDirectSound3DListener, @ptrCast(self)), pvVelocity);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_SetAllParameters(self: *const T, pcListener: ?*DS3DLISTENER, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).SetAllParameters(@as(*const IDirectSound3DListener, @ptrCast(self)), pcListener, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_SetDistanceFactor(self: *const T, flDistanceFactor: f32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).SetDistanceFactor(@as(*const IDirectSound3DListener, @ptrCast(self)), flDistanceFactor, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_SetDopplerFactor(self: *const T, flDopplerFactor: f32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).SetDopplerFactor(@as(*const IDirectSound3DListener, @ptrCast(self)), flDopplerFactor, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_SetOrientation(self: *const T, xFront: f32, yFront: f32, zFront: f32, xTop: f32, yTop: f32, zTop: f32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).SetOrientation(@as(*const IDirectSound3DListener, @ptrCast(self)), xFront, yFront, zFront, xTop, yTop, zTop, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_SetPosition(self: *const T, x: f32, y: f32, z: f32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).SetPosition(@as(*const IDirectSound3DListener, @ptrCast(self)), x, y, z, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_SetRolloffFactor(self: *const T, flRolloffFactor: f32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).SetRolloffFactor(@as(*const IDirectSound3DListener, @ptrCast(self)), flRolloffFactor, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_SetVelocity(self: *const T, x: f32, y: f32, z: f32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).SetVelocity(@as(*const IDirectSound3DListener, @ptrCast(self)), x, y, z, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DListener_CommitDeferredSettings(self: *const T) HRESULT {
                return @as(*const IDirectSound3DListener.VTable, @ptrCast(self.vtable)).CommitDeferredSettings(@as(*const IDirectSound3DListener, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDirectSound3DBuffer_Value = Guid.initString("279afa86-4981-11ce-a521-0020af0be560");
pub const IID_IDirectSound3DBuffer = &IID_IDirectSound3DBuffer_Value;
pub const IDirectSound3DBuffer = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                pDs3dBuffer: ?*DS3DBUFFER,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                pDs3dBuffer: ?*DS3DBUFFER,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetConeAngles: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                pdwInsideConeAngle: ?*u32,
                pdwOutsideConeAngle: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                pdwInsideConeAngle: ?*u32,
                pdwOutsideConeAngle: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetConeOrientation: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                pvOrientation: ?*D3DVECTOR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                pvOrientation: ?*D3DVECTOR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetConeOutsideVolume: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                plConeOutsideVolume: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                plConeOutsideVolume: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMaxDistance: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                pflMaxDistance: ?*f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                pflMaxDistance: ?*f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMinDistance: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                pflMinDistance: ?*f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                pflMinDistance: ?*f32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetMode: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                pdwMode: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                pdwMode: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPosition: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                pvPosition: ?*D3DVECTOR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                pvPosition: ?*D3DVECTOR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetVelocity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                pvVelocity: ?*D3DVECTOR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                pvVelocity: ?*D3DVECTOR,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                pcDs3dBuffer: ?*DS3DBUFFER,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                pcDs3dBuffer: ?*DS3DBUFFER,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetConeAngles: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                dwInsideConeAngle: u32,
                dwOutsideConeAngle: u32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                dwInsideConeAngle: u32,
                dwOutsideConeAngle: u32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetConeOrientation: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                x: f32,
                y: f32,
                z: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                x: f32,
                y: f32,
                z: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetConeOutsideVolume: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                lConeOutsideVolume: i32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                lConeOutsideVolume: i32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetMaxDistance: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                flMaxDistance: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                flMaxDistance: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetMinDistance: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                flMinDistance: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                flMinDistance: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetMode: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                dwMode: u32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                dwMode: u32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetPosition: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                x: f32,
                y: f32,
                z: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                x: f32,
                y: f32,
                z: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetVelocity: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSound3DBuffer,
                x: f32,
                y: f32,
                z: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSound3DBuffer,
                x: f32,
                y: f32,
                z: f32,
                dwApply: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_GetAllParameters(self: *const T, pDs3dBuffer: ?*DS3DBUFFER) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).GetAllParameters(@as(*const IDirectSound3DBuffer, @ptrCast(self)), pDs3dBuffer);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_GetConeAngles(self: *const T, pdwInsideConeAngle: ?*u32, pdwOutsideConeAngle: ?*u32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).GetConeAngles(@as(*const IDirectSound3DBuffer, @ptrCast(self)), pdwInsideConeAngle, pdwOutsideConeAngle);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_GetConeOrientation(self: *const T, pvOrientation: ?*D3DVECTOR) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).GetConeOrientation(@as(*const IDirectSound3DBuffer, @ptrCast(self)), pvOrientation);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_GetConeOutsideVolume(self: *const T, plConeOutsideVolume: ?*i32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).GetConeOutsideVolume(@as(*const IDirectSound3DBuffer, @ptrCast(self)), plConeOutsideVolume);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_GetMaxDistance(self: *const T, pflMaxDistance: ?*f32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).GetMaxDistance(@as(*const IDirectSound3DBuffer, @ptrCast(self)), pflMaxDistance);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_GetMinDistance(self: *const T, pflMinDistance: ?*f32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).GetMinDistance(@as(*const IDirectSound3DBuffer, @ptrCast(self)), pflMinDistance);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_GetMode(self: *const T, pdwMode: ?*u32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).GetMode(@as(*const IDirectSound3DBuffer, @ptrCast(self)), pdwMode);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_GetPosition(self: *const T, pvPosition: ?*D3DVECTOR) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).GetPosition(@as(*const IDirectSound3DBuffer, @ptrCast(self)), pvPosition);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_GetVelocity(self: *const T, pvVelocity: ?*D3DVECTOR) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).GetVelocity(@as(*const IDirectSound3DBuffer, @ptrCast(self)), pvVelocity);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_SetAllParameters(self: *const T, pcDs3dBuffer: ?*DS3DBUFFER, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).SetAllParameters(@as(*const IDirectSound3DBuffer, @ptrCast(self)), pcDs3dBuffer, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_SetConeAngles(self: *const T, dwInsideConeAngle: u32, dwOutsideConeAngle: u32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).SetConeAngles(@as(*const IDirectSound3DBuffer, @ptrCast(self)), dwInsideConeAngle, dwOutsideConeAngle, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_SetConeOrientation(self: *const T, x: f32, y: f32, z: f32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).SetConeOrientation(@as(*const IDirectSound3DBuffer, @ptrCast(self)), x, y, z, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_SetConeOutsideVolume(self: *const T, lConeOutsideVolume: i32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).SetConeOutsideVolume(@as(*const IDirectSound3DBuffer, @ptrCast(self)), lConeOutsideVolume, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_SetMaxDistance(self: *const T, flMaxDistance: f32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).SetMaxDistance(@as(*const IDirectSound3DBuffer, @ptrCast(self)), flMaxDistance, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_SetMinDistance(self: *const T, flMinDistance: f32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).SetMinDistance(@as(*const IDirectSound3DBuffer, @ptrCast(self)), flMinDistance, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_SetMode(self: *const T, dwMode: u32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).SetMode(@as(*const IDirectSound3DBuffer, @ptrCast(self)), dwMode, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_SetPosition(self: *const T, x: f32, y: f32, z: f32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).SetPosition(@as(*const IDirectSound3DBuffer, @ptrCast(self)), x, y, z, dwApply);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSound3DBuffer_SetVelocity(self: *const T, x: f32, y: f32, z: f32, dwApply: u32) HRESULT {
                return @as(*const IDirectSound3DBuffer.VTable, @ptrCast(self.vtable)).SetVelocity(@as(*const IDirectSound3DBuffer, @ptrCast(self)), x, y, z, dwApply);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDirectSoundCapture_Value = Guid.initString("b0210781-89cd-11d0-af08-00a0c925cd16");
pub const IID_IDirectSoundCapture = &IID_IDirectSoundCapture_Value;
pub const IDirectSoundCapture = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        CreateCaptureBuffer: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCapture,
                pcDSCBufferDesc: ?*DSCBUFFERDESC,
                ppDSCBuffer: ?*?*IDirectSoundCaptureBuffer,
                pUnkOuter: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCapture,
                pcDSCBufferDesc: ?*DSCBUFFERDESC,
                ppDSCBuffer: ?*?*IDirectSoundCaptureBuffer,
                pUnkOuter: ?*IUnknown,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCaps: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCapture,
                pDSCCaps: ?*DSCCAPS,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCapture,
                pDSCCaps: ?*DSCCAPS,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Initialize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCapture,
                pcGuidDevice: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCapture,
                pcGuidDevice: ?*const Guid,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCapture_CreateCaptureBuffer(self: *const T, pcDSCBufferDesc: ?*DSCBUFFERDESC, ppDSCBuffer: ?*?*IDirectSoundCaptureBuffer, pUnkOuter: ?*IUnknown) HRESULT {
                return @as(*const IDirectSoundCapture.VTable, @ptrCast(self.vtable)).CreateCaptureBuffer(@as(*const IDirectSoundCapture, @ptrCast(self)), pcDSCBufferDesc, ppDSCBuffer, pUnkOuter);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCapture_GetCaps(self: *const T, pDSCCaps: ?*DSCCAPS) HRESULT {
                return @as(*const IDirectSoundCapture.VTable, @ptrCast(self.vtable)).GetCaps(@as(*const IDirectSoundCapture, @ptrCast(self)), pDSCCaps);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCapture_Initialize(self: *const T, pcGuidDevice: ?*const Guid) HRESULT {
                return @as(*const IDirectSoundCapture.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IDirectSoundCapture, @ptrCast(self)), pcGuidDevice);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDirectSoundCaptureBuffer_Value = Guid.initString("b0210782-89cd-11d0-af08-00a0c925cd16");
pub const IID_IDirectSoundCaptureBuffer = &IID_IDirectSoundCaptureBuffer_Value;
pub const IDirectSoundCaptureBuffer = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        GetCaps: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureBuffer,
                pDSCBCaps: ?*DSCBCAPS,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureBuffer,
                pDSCBCaps: ?*DSCBCAPS,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetCurrentPosition: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureBuffer,
                pdwCapturePosition: ?*u32,
                pdwReadPosition: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureBuffer,
                pdwCapturePosition: ?*u32,
                pdwReadPosition: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFormat: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureBuffer,
                // TODO: what to do with BytesParamIndex 1?
                pwfxFormat: ?*WAVEFORMATEX,
                dwSizeAllocated: u32,
                pdwSizeWritten: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureBuffer,
                // TODO: what to do with BytesParamIndex 1?
                pwfxFormat: ?*WAVEFORMATEX,
                dwSizeAllocated: u32,
                pdwSizeWritten: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetStatus: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureBuffer,
                pdwStatus: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureBuffer,
                pdwStatus: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Initialize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureBuffer,
                pDirectSoundCapture: ?*IDirectSoundCapture,
                pcDSCBufferDesc: ?*DSCBUFFERDESC,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureBuffer,
                pDirectSoundCapture: ?*IDirectSoundCapture,
                pcDSCBufferDesc: ?*DSCBUFFERDESC,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Lock: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureBuffer,
                dwOffset: u32,
                dwBytes: u32,
                ppvAudioPtr1: ?*?*anyopaque,
                pdwAudioBytes1: ?*u32,
                ppvAudioPtr2: ?*?*anyopaque,
                pdwAudioBytes2: ?*u32,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureBuffer,
                dwOffset: u32,
                dwBytes: u32,
                ppvAudioPtr1: ?*?*anyopaque,
                pdwAudioBytes1: ?*u32,
                ppvAudioPtr2: ?*?*anyopaque,
                pdwAudioBytes2: ?*u32,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Start: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureBuffer,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureBuffer,
                dwFlags: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Stop: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureBuffer,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Unlock: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureBuffer,
                // TODO: what to do with BytesParamIndex 1?
                pvAudioPtr1: ?*anyopaque,
                dwAudioBytes1: u32,
                // TODO: what to do with BytesParamIndex 3?
                pvAudioPtr2: ?*anyopaque,
                dwAudioBytes2: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureBuffer,
                // TODO: what to do with BytesParamIndex 1?
                pvAudioPtr1: ?*anyopaque,
                dwAudioBytes1: u32,
                // TODO: what to do with BytesParamIndex 3?
                pvAudioPtr2: ?*anyopaque,
                dwAudioBytes2: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureBuffer_GetCaps(self: *const T, pDSCBCaps: ?*DSCBCAPS) HRESULT {
                return @as(*const IDirectSoundCaptureBuffer.VTable, @ptrCast(self.vtable)).GetCaps(@as(*const IDirectSoundCaptureBuffer, @ptrCast(self)), pDSCBCaps);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureBuffer_GetCurrentPosition(self: *const T, pdwCapturePosition: ?*u32, pdwReadPosition: ?*u32) HRESULT {
                return @as(*const IDirectSoundCaptureBuffer.VTable, @ptrCast(self.vtable)).GetCurrentPosition(@as(*const IDirectSoundCaptureBuffer, @ptrCast(self)), pdwCapturePosition, pdwReadPosition);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureBuffer_GetFormat(self: *const T, pwfxFormat: ?*WAVEFORMATEX, dwSizeAllocated: u32, pdwSizeWritten: ?*u32) HRESULT {
                return @as(*const IDirectSoundCaptureBuffer.VTable, @ptrCast(self.vtable)).GetFormat(@as(*const IDirectSoundCaptureBuffer, @ptrCast(self)), pwfxFormat, dwSizeAllocated, pdwSizeWritten);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureBuffer_GetStatus(self: *const T, pdwStatus: ?*u32) HRESULT {
                return @as(*const IDirectSoundCaptureBuffer.VTable, @ptrCast(self.vtable)).GetStatus(@as(*const IDirectSoundCaptureBuffer, @ptrCast(self)), pdwStatus);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureBuffer_Initialize(self: *const T, pDirectSoundCapture: ?*IDirectSoundCapture, pcDSCBufferDesc: ?*DSCBUFFERDESC) HRESULT {
                return @as(*const IDirectSoundCaptureBuffer.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IDirectSoundCaptureBuffer, @ptrCast(self)), pDirectSoundCapture, pcDSCBufferDesc);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureBuffer_Lock(self: *const T, dwOffset: u32, dwBytes: u32, ppvAudioPtr1: ?*?*anyopaque, pdwAudioBytes1: ?*u32, ppvAudioPtr2: ?*?*anyopaque, pdwAudioBytes2: ?*u32, dwFlags: u32) HRESULT {
                return @as(*const IDirectSoundCaptureBuffer.VTable, @ptrCast(self.vtable)).Lock(@as(*const IDirectSoundCaptureBuffer, @ptrCast(self)), dwOffset, dwBytes, ppvAudioPtr1, pdwAudioBytes1, ppvAudioPtr2, pdwAudioBytes2, dwFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureBuffer_Start(self: *const T, dwFlags: u32) HRESULT {
                return @as(*const IDirectSoundCaptureBuffer.VTable, @ptrCast(self.vtable)).Start(@as(*const IDirectSoundCaptureBuffer, @ptrCast(self)), dwFlags);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureBuffer_Stop(self: *const T) HRESULT {
                return @as(*const IDirectSoundCaptureBuffer.VTable, @ptrCast(self.vtable)).Stop(@as(*const IDirectSoundCaptureBuffer, @ptrCast(self)));
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureBuffer_Unlock(self: *const T, pvAudioPtr1: ?*anyopaque, dwAudioBytes1: u32, pvAudioPtr2: ?*anyopaque, dwAudioBytes2: u32) HRESULT {
                return @as(*const IDirectSoundCaptureBuffer.VTable, @ptrCast(self.vtable)).Unlock(@as(*const IDirectSoundCaptureBuffer, @ptrCast(self)), pvAudioPtr1, dwAudioBytes1, pvAudioPtr2, dwAudioBytes2);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDirectSoundCaptureBuffer8_Value = Guid.initString("00990df4-0dbb-4872-833e-6d303e80aeb6");
pub const IID_IDirectSoundCaptureBuffer8 = &IID_IDirectSoundCaptureBuffer8_Value;
pub const IDirectSoundCaptureBuffer8 = extern struct {
    pub const VTable = extern struct {
        base: IDirectSoundCaptureBuffer.VTable,
        GetObjectInPath: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureBuffer8,
                rguidObject: ?*const Guid,
                dwIndex: u32,
                rguidInterface: ?*const Guid,
                ppObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureBuffer8,
                rguidObject: ?*const Guid,
                dwIndex: u32,
                rguidInterface: ?*const Guid,
                ppObject: ?*?*anyopaque,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetFXStatus: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureBuffer8,
                dwEffectsCount: u32,
                pdwFXStatus: [*]u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureBuffer8,
                dwEffectsCount: u32,
                pdwFXStatus: [*]u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IDirectSoundCaptureBuffer.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureBuffer8_GetObjectInPath(self: *const T, rguidObject: ?*const Guid, dwIndex: u32, rguidInterface: ?*const Guid, ppObject: ?*?*anyopaque) HRESULT {
                return @as(*const IDirectSoundCaptureBuffer8.VTable, @ptrCast(self.vtable)).GetObjectInPath(@as(*const IDirectSoundCaptureBuffer8, @ptrCast(self)), rguidObject, dwIndex, rguidInterface, ppObject);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureBuffer8_GetFXStatus(self: *const T, dwEffectsCount: u32, pdwFXStatus: [*]u32) HRESULT {
                return @as(*const IDirectSoundCaptureBuffer8.VTable, @ptrCast(self.vtable)).GetFXStatus(@as(*const IDirectSoundCaptureBuffer8, @ptrCast(self)), dwEffectsCount, pdwFXStatus);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDirectSoundNotify_Value = Guid.initString("b0210783-89cd-11d0-af08-00a0c925cd16");
pub const IID_IDirectSoundNotify = &IID_IDirectSoundNotify_Value;
pub const IDirectSoundNotify = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetNotificationPositions: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundNotify,
                dwPositionNotifies: u32,
                pcPositionNotifies: [*]DSBPOSITIONNOTIFY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundNotify,
                dwPositionNotifies: u32,
                pcPositionNotifies: [*]DSBPOSITIONNOTIFY,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundNotify_SetNotificationPositions(self: *const T, dwPositionNotifies: u32, pcPositionNotifies: [*]DSBPOSITIONNOTIFY) HRESULT {
                return @as(*const IDirectSoundNotify.VTable, @ptrCast(self.vtable)).SetNotificationPositions(@as(*const IDirectSoundNotify, @ptrCast(self)), dwPositionNotifies, pcPositionNotifies);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const DSFXGargle = extern struct {
    dwRateHz: u32,
    dwWaveShape: u32,
};

const IID_IDirectSoundFXGargle_Value = Guid.initString("d616f352-d622-11ce-aac5-0020af0b99a3");
pub const IID_IDirectSoundFXGargle = &IID_IDirectSoundFXGargle_Value;
pub const IDirectSoundFXGargle = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXGargle,
                pcDsFxGargle: ?*DSFXGargle,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXGargle,
                pcDsFxGargle: ?*DSFXGargle,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXGargle,
                pDsFxGargle: ?*DSFXGargle,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXGargle,
                pDsFxGargle: ?*DSFXGargle,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXGargle_SetAllParameters(self: *const T, pcDsFxGargle: ?*DSFXGargle) HRESULT {
                return @as(*const IDirectSoundFXGargle.VTable, @ptrCast(self.vtable)).SetAllParameters(@as(*const IDirectSoundFXGargle, @ptrCast(self)), pcDsFxGargle);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXGargle_GetAllParameters(self: *const T, pDsFxGargle: ?*DSFXGargle) HRESULT {
                return @as(*const IDirectSoundFXGargle.VTable, @ptrCast(self.vtable)).GetAllParameters(@as(*const IDirectSoundFXGargle, @ptrCast(self)), pDsFxGargle);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const DSFXChorus = extern struct {
    fWetDryMix: f32,
    fDepth: f32,
    fFeedback: f32,
    fFrequency: f32,
    lWaveform: i32,
    fDelay: f32,
    lPhase: i32,
};

const IID_IDirectSoundFXChorus_Value = Guid.initString("880842e3-145f-43e6-a934-a71806e50547");
pub const IID_IDirectSoundFXChorus = &IID_IDirectSoundFXChorus_Value;
pub const IDirectSoundFXChorus = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXChorus,
                pcDsFxChorus: ?*DSFXChorus,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXChorus,
                pcDsFxChorus: ?*DSFXChorus,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXChorus,
                pDsFxChorus: ?*DSFXChorus,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXChorus,
                pDsFxChorus: ?*DSFXChorus,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXChorus_SetAllParameters(self: *const T, pcDsFxChorus: ?*DSFXChorus) HRESULT {
                return @as(*const IDirectSoundFXChorus.VTable, @ptrCast(self.vtable)).SetAllParameters(@as(*const IDirectSoundFXChorus, @ptrCast(self)), pcDsFxChorus);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXChorus_GetAllParameters(self: *const T, pDsFxChorus: ?*DSFXChorus) HRESULT {
                return @as(*const IDirectSoundFXChorus.VTable, @ptrCast(self.vtable)).GetAllParameters(@as(*const IDirectSoundFXChorus, @ptrCast(self)), pDsFxChorus);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const DSFXFlanger = extern struct {
    fWetDryMix: f32,
    fDepth: f32,
    fFeedback: f32,
    fFrequency: f32,
    lWaveform: i32,
    fDelay: f32,
    lPhase: i32,
};

const IID_IDirectSoundFXFlanger_Value = Guid.initString("903e9878-2c92-4072-9b2c-ea68f5396783");
pub const IID_IDirectSoundFXFlanger = &IID_IDirectSoundFXFlanger_Value;
pub const IDirectSoundFXFlanger = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXFlanger,
                pcDsFxFlanger: ?*DSFXFlanger,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXFlanger,
                pcDsFxFlanger: ?*DSFXFlanger,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXFlanger,
                pDsFxFlanger: ?*DSFXFlanger,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXFlanger,
                pDsFxFlanger: ?*DSFXFlanger,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXFlanger_SetAllParameters(self: *const T, pcDsFxFlanger: ?*DSFXFlanger) HRESULT {
                return @as(*const IDirectSoundFXFlanger.VTable, @ptrCast(self.vtable)).SetAllParameters(@as(*const IDirectSoundFXFlanger, @ptrCast(self)), pcDsFxFlanger);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXFlanger_GetAllParameters(self: *const T, pDsFxFlanger: ?*DSFXFlanger) HRESULT {
                return @as(*const IDirectSoundFXFlanger.VTable, @ptrCast(self.vtable)).GetAllParameters(@as(*const IDirectSoundFXFlanger, @ptrCast(self)), pDsFxFlanger);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const DSFXEcho = extern struct {
    fWetDryMix: f32,
    fFeedback: f32,
    fLeftDelay: f32,
    fRightDelay: f32,
    lPanDelay: i32,
};

const IID_IDirectSoundFXEcho_Value = Guid.initString("8bd28edf-50db-4e92-a2bd-445488d1ed42");
pub const IID_IDirectSoundFXEcho = &IID_IDirectSoundFXEcho_Value;
pub const IDirectSoundFXEcho = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXEcho,
                pcDsFxEcho: ?*DSFXEcho,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXEcho,
                pcDsFxEcho: ?*DSFXEcho,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXEcho,
                pDsFxEcho: ?*DSFXEcho,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXEcho,
                pDsFxEcho: ?*DSFXEcho,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXEcho_SetAllParameters(self: *const T, pcDsFxEcho: ?*DSFXEcho) HRESULT {
                return @as(*const IDirectSoundFXEcho.VTable, @ptrCast(self.vtable)).SetAllParameters(@as(*const IDirectSoundFXEcho, @ptrCast(self)), pcDsFxEcho);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXEcho_GetAllParameters(self: *const T, pDsFxEcho: ?*DSFXEcho) HRESULT {
                return @as(*const IDirectSoundFXEcho.VTable, @ptrCast(self.vtable)).GetAllParameters(@as(*const IDirectSoundFXEcho, @ptrCast(self)), pDsFxEcho);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const DSFXDistortion = extern struct {
    fGain: f32,
    fEdge: f32,
    fPostEQCenterFrequency: f32,
    fPostEQBandwidth: f32,
    fPreLowpassCutoff: f32,
};

const IID_IDirectSoundFXDistortion_Value = Guid.initString("8ecf4326-455f-4d8b-bda9-8d5d3e9e3e0b");
pub const IID_IDirectSoundFXDistortion = &IID_IDirectSoundFXDistortion_Value;
pub const IDirectSoundFXDistortion = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXDistortion,
                pcDsFxDistortion: ?*DSFXDistortion,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXDistortion,
                pcDsFxDistortion: ?*DSFXDistortion,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXDistortion,
                pDsFxDistortion: ?*DSFXDistortion,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXDistortion,
                pDsFxDistortion: ?*DSFXDistortion,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXDistortion_SetAllParameters(self: *const T, pcDsFxDistortion: ?*DSFXDistortion) HRESULT {
                return @as(*const IDirectSoundFXDistortion.VTable, @ptrCast(self.vtable)).SetAllParameters(@as(*const IDirectSoundFXDistortion, @ptrCast(self)), pcDsFxDistortion);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXDistortion_GetAllParameters(self: *const T, pDsFxDistortion: ?*DSFXDistortion) HRESULT {
                return @as(*const IDirectSoundFXDistortion.VTable, @ptrCast(self.vtable)).GetAllParameters(@as(*const IDirectSoundFXDistortion, @ptrCast(self)), pDsFxDistortion);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const DSFXCompressor = extern struct {
    fGain: f32,
    fAttack: f32,
    fRelease: f32,
    fThreshold: f32,
    fRatio: f32,
    fPredelay: f32,
};

const IID_IDirectSoundFXCompressor_Value = Guid.initString("4bbd1154-62f6-4e2c-a15c-d3b6c417f7a0");
pub const IID_IDirectSoundFXCompressor = &IID_IDirectSoundFXCompressor_Value;
pub const IDirectSoundFXCompressor = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXCompressor,
                pcDsFxCompressor: ?*DSFXCompressor,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXCompressor,
                pcDsFxCompressor: ?*DSFXCompressor,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXCompressor,
                pDsFxCompressor: ?*DSFXCompressor,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXCompressor,
                pDsFxCompressor: ?*DSFXCompressor,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXCompressor_SetAllParameters(self: *const T, pcDsFxCompressor: ?*DSFXCompressor) HRESULT {
                return @as(*const IDirectSoundFXCompressor.VTable, @ptrCast(self.vtable)).SetAllParameters(@as(*const IDirectSoundFXCompressor, @ptrCast(self)), pcDsFxCompressor);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXCompressor_GetAllParameters(self: *const T, pDsFxCompressor: ?*DSFXCompressor) HRESULT {
                return @as(*const IDirectSoundFXCompressor.VTable, @ptrCast(self.vtable)).GetAllParameters(@as(*const IDirectSoundFXCompressor, @ptrCast(self)), pDsFxCompressor);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const DSFXParamEq = extern struct {
    fCenter: f32,
    fBandwidth: f32,
    fGain: f32,
};

const IID_IDirectSoundFXParamEq_Value = Guid.initString("c03ca9fe-fe90-4204-8078-82334cd177da");
pub const IID_IDirectSoundFXParamEq = &IID_IDirectSoundFXParamEq_Value;
pub const IDirectSoundFXParamEq = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXParamEq,
                pcDsFxParamEq: ?*DSFXParamEq,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXParamEq,
                pcDsFxParamEq: ?*DSFXParamEq,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXParamEq,
                pDsFxParamEq: ?*DSFXParamEq,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXParamEq,
                pDsFxParamEq: ?*DSFXParamEq,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXParamEq_SetAllParameters(self: *const T, pcDsFxParamEq: ?*DSFXParamEq) HRESULT {
                return @as(*const IDirectSoundFXParamEq.VTable, @ptrCast(self.vtable)).SetAllParameters(@as(*const IDirectSoundFXParamEq, @ptrCast(self)), pcDsFxParamEq);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXParamEq_GetAllParameters(self: *const T, pDsFxParamEq: ?*DSFXParamEq) HRESULT {
                return @as(*const IDirectSoundFXParamEq.VTable, @ptrCast(self.vtable)).GetAllParameters(@as(*const IDirectSoundFXParamEq, @ptrCast(self)), pDsFxParamEq);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const DSFXI3DL2Reverb = extern struct {
    lRoom: i32,
    lRoomHF: i32,
    flRoomRolloffFactor: f32,
    flDecayTime: f32,
    flDecayHFRatio: f32,
    lReflections: i32,
    flReflectionsDelay: f32,
    lReverb: i32,
    flReverbDelay: f32,
    flDiffusion: f32,
    flDensity: f32,
    flHFReference: f32,
};

const IID_IDirectSoundFXI3DL2Reverb_Value = Guid.initString("4b166a6a-0d66-43f3-80e3-ee6280dee1a4");
pub const IID_IDirectSoundFXI3DL2Reverb = &IID_IDirectSoundFXI3DL2Reverb_Value;
pub const IDirectSoundFXI3DL2Reverb = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXI3DL2Reverb,
                pcDsFxI3DL2Reverb: ?*DSFXI3DL2Reverb,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXI3DL2Reverb,
                pcDsFxI3DL2Reverb: ?*DSFXI3DL2Reverb,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXI3DL2Reverb,
                pDsFxI3DL2Reverb: ?*DSFXI3DL2Reverb,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXI3DL2Reverb,
                pDsFxI3DL2Reverb: ?*DSFXI3DL2Reverb,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetPreset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXI3DL2Reverb,
                dwPreset: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXI3DL2Reverb,
                dwPreset: u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetPreset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXI3DL2Reverb,
                pdwPreset: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXI3DL2Reverb,
                pdwPreset: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        SetQuality: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXI3DL2Reverb,
                lQuality: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXI3DL2Reverb,
                lQuality: i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetQuality: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXI3DL2Reverb,
                plQuality: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXI3DL2Reverb,
                plQuality: ?*i32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXI3DL2Reverb_SetAllParameters(self: *const T, pcDsFxI3DL2Reverb: ?*DSFXI3DL2Reverb) HRESULT {
                return @as(*const IDirectSoundFXI3DL2Reverb.VTable, @ptrCast(self.vtable)).SetAllParameters(@as(*const IDirectSoundFXI3DL2Reverb, @ptrCast(self)), pcDsFxI3DL2Reverb);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXI3DL2Reverb_GetAllParameters(self: *const T, pDsFxI3DL2Reverb: ?*DSFXI3DL2Reverb) HRESULT {
                return @as(*const IDirectSoundFXI3DL2Reverb.VTable, @ptrCast(self.vtable)).GetAllParameters(@as(*const IDirectSoundFXI3DL2Reverb, @ptrCast(self)), pDsFxI3DL2Reverb);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXI3DL2Reverb_SetPreset(self: *const T, dwPreset: u32) HRESULT {
                return @as(*const IDirectSoundFXI3DL2Reverb.VTable, @ptrCast(self.vtable)).SetPreset(@as(*const IDirectSoundFXI3DL2Reverb, @ptrCast(self)), dwPreset);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXI3DL2Reverb_GetPreset(self: *const T, pdwPreset: ?*u32) HRESULT {
                return @as(*const IDirectSoundFXI3DL2Reverb.VTable, @ptrCast(self.vtable)).GetPreset(@as(*const IDirectSoundFXI3DL2Reverb, @ptrCast(self)), pdwPreset);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXI3DL2Reverb_SetQuality(self: *const T, lQuality: i32) HRESULT {
                return @as(*const IDirectSoundFXI3DL2Reverb.VTable, @ptrCast(self.vtable)).SetQuality(@as(*const IDirectSoundFXI3DL2Reverb, @ptrCast(self)), lQuality);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXI3DL2Reverb_GetQuality(self: *const T, plQuality: ?*i32) HRESULT {
                return @as(*const IDirectSoundFXI3DL2Reverb.VTable, @ptrCast(self.vtable)).GetQuality(@as(*const IDirectSoundFXI3DL2Reverb, @ptrCast(self)), plQuality);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const DSFXWavesReverb = extern struct {
    fInGain: f32,
    fReverbMix: f32,
    fReverbTime: f32,
    fHighFreqRTRatio: f32,
};

const IID_IDirectSoundFXWavesReverb_Value = Guid.initString("46858c3a-0dc6-45e3-b760-d4eef16cb325");
pub const IID_IDirectSoundFXWavesReverb = &IID_IDirectSoundFXWavesReverb_Value;
pub const IDirectSoundFXWavesReverb = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXWavesReverb,
                pcDsFxWavesReverb: ?*DSFXWavesReverb,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXWavesReverb,
                pcDsFxWavesReverb: ?*DSFXWavesReverb,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFXWavesReverb,
                pDsFxWavesReverb: ?*DSFXWavesReverb,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFXWavesReverb,
                pDsFxWavesReverb: ?*DSFXWavesReverb,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXWavesReverb_SetAllParameters(self: *const T, pcDsFxWavesReverb: ?*DSFXWavesReverb) HRESULT {
                return @as(*const IDirectSoundFXWavesReverb.VTable, @ptrCast(self.vtable)).SetAllParameters(@as(*const IDirectSoundFXWavesReverb, @ptrCast(self)), pcDsFxWavesReverb);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFXWavesReverb_GetAllParameters(self: *const T, pDsFxWavesReverb: ?*DSFXWavesReverb) HRESULT {
                return @as(*const IDirectSoundFXWavesReverb.VTable, @ptrCast(self.vtable)).GetAllParameters(@as(*const IDirectSoundFXWavesReverb, @ptrCast(self)), pDsFxWavesReverb);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const DSCFXAec = extern struct {
    fEnable: BOOL,
    fNoiseFill: BOOL,
    dwMode: u32,
};

const IID_IDirectSoundCaptureFXAec_Value = Guid.initString("ad74143d-903d-4ab7-8066-28d363036d65");
pub const IID_IDirectSoundCaptureFXAec = &IID_IDirectSoundCaptureFXAec_Value;
pub const IDirectSoundCaptureFXAec = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureFXAec,
                pDscFxAec: ?*DSCFXAec,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureFXAec,
                pDscFxAec: ?*DSCFXAec,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureFXAec,
                pDscFxAec: ?*DSCFXAec,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureFXAec,
                pDscFxAec: ?*DSCFXAec,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetStatus: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureFXAec,
                pdwStatus: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureFXAec,
                pdwStatus: ?*u32,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureFXAec,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureFXAec,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureFXAec_SetAllParameters(self: *const T, pDscFxAec: ?*DSCFXAec) HRESULT {
                return @as(*const IDirectSoundCaptureFXAec.VTable, @ptrCast(self.vtable)).SetAllParameters(@as(*const IDirectSoundCaptureFXAec, @ptrCast(self)), pDscFxAec);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureFXAec_GetAllParameters(self: *const T, pDscFxAec: ?*DSCFXAec) HRESULT {
                return @as(*const IDirectSoundCaptureFXAec.VTable, @ptrCast(self.vtable)).GetAllParameters(@as(*const IDirectSoundCaptureFXAec, @ptrCast(self)), pDscFxAec);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureFXAec_GetStatus(self: *const T, pdwStatus: ?*u32) HRESULT {
                return @as(*const IDirectSoundCaptureFXAec.VTable, @ptrCast(self.vtable)).GetStatus(@as(*const IDirectSoundCaptureFXAec, @ptrCast(self)), pdwStatus);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureFXAec_Reset(self: *const T) HRESULT {
                return @as(*const IDirectSoundCaptureFXAec.VTable, @ptrCast(self.vtable)).Reset(@as(*const IDirectSoundCaptureFXAec, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

pub const DSCFXNoiseSuppress = extern struct {
    fEnable: BOOL,
};

const IID_IDirectSoundCaptureFXNoiseSuppress_Value = Guid.initString("ed311e41-fbae-4175-9625-cd0854f693ca");
pub const IID_IDirectSoundCaptureFXNoiseSuppress = &IID_IDirectSoundCaptureFXNoiseSuppress_Value;
pub const IDirectSoundCaptureFXNoiseSuppress = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        SetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureFXNoiseSuppress,
                pcDscFxNoiseSuppress: ?*DSCFXNoiseSuppress,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureFXNoiseSuppress,
                pcDscFxNoiseSuppress: ?*DSCFXNoiseSuppress,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        GetAllParameters: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureFXNoiseSuppress,
                pDscFxNoiseSuppress: ?*DSCFXNoiseSuppress,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureFXNoiseSuppress,
                pDscFxNoiseSuppress: ?*DSCFXNoiseSuppress,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
        Reset: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundCaptureFXNoiseSuppress,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundCaptureFXNoiseSuppress,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureFXNoiseSuppress_SetAllParameters(self: *const T, pcDscFxNoiseSuppress: ?*DSCFXNoiseSuppress) HRESULT {
                return @as(*const IDirectSoundCaptureFXNoiseSuppress.VTable, @ptrCast(self.vtable)).SetAllParameters(@as(*const IDirectSoundCaptureFXNoiseSuppress, @ptrCast(self)), pcDscFxNoiseSuppress);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureFXNoiseSuppress_GetAllParameters(self: *const T, pDscFxNoiseSuppress: ?*DSCFXNoiseSuppress) HRESULT {
                return @as(*const IDirectSoundCaptureFXNoiseSuppress.VTable, @ptrCast(self.vtable)).GetAllParameters(@as(*const IDirectSoundCaptureFXNoiseSuppress, @ptrCast(self)), pDscFxNoiseSuppress);
            }
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundCaptureFXNoiseSuppress_Reset(self: *const T) HRESULT {
                return @as(*const IDirectSoundCaptureFXNoiseSuppress.VTable, @ptrCast(self.vtable)).Reset(@as(*const IDirectSoundCaptureFXNoiseSuppress, @ptrCast(self)));
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

const IID_IDirectSoundFullDuplex_Value = Guid.initString("edcb4c7a-daab-4216-a42e-6c50596ddc1d");
pub const IID_IDirectSoundFullDuplex = &IID_IDirectSoundFullDuplex_Value;
pub const IDirectSoundFullDuplex = extern struct {
    pub const VTable = extern struct {
        base: IUnknown.VTable,
        Initialize: switch (@import("builtin").zig_backend) {
            .stage1 => fn (
                self: *const IDirectSoundFullDuplex,
                pCaptureGuid: ?*const Guid,
                pRenderGuid: ?*const Guid,
                lpDscBufferDesc: ?*DSCBUFFERDESC,
                lpDsBufferDesc: ?*DSBUFFERDESC,
                hWnd: ?HWND,
                dwLevel: u32,
                lplpDirectSoundCaptureBuffer8: ?*?*IDirectSoundCaptureBuffer8,
                lplpDirectSoundBuffer8: ?*?*IDirectSoundBuffer8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
            else => *const fn (
                self: *const IDirectSoundFullDuplex,
                pCaptureGuid: ?*const Guid,
                pRenderGuid: ?*const Guid,
                lpDscBufferDesc: ?*DSCBUFFERDESC,
                lpDsBufferDesc: ?*DSBUFFERDESC,
                hWnd: ?HWND,
                dwLevel: u32,
                lplpDirectSoundCaptureBuffer8: ?*?*IDirectSoundCaptureBuffer8,
                lplpDirectSoundBuffer8: ?*?*IDirectSoundBuffer8,
            ) callconv(@import("std").os.windows.WINAPI) HRESULT,
        },
    };
    vtable: *const VTable,
    pub fn MethodMixin(comptime T: type) type {
        return struct {
            pub usingnamespace IUnknown.MethodMixin(T);
            // NOTE: method is namespaced with interface name to avoid conflicts for now
            pub inline fn IDirectSoundFullDuplex_Initialize(self: *const T, pCaptureGuid: ?*const Guid, pRenderGuid: ?*const Guid, lpDscBufferDesc: ?*DSCBUFFERDESC, lpDsBufferDesc: ?*DSBUFFERDESC, hWnd: ?HWND, dwLevel: u32, lplpDirectSoundCaptureBuffer8: ?*?*IDirectSoundCaptureBuffer8, lplpDirectSoundBuffer8: ?*?*IDirectSoundBuffer8) HRESULT {
                return @as(*const IDirectSoundFullDuplex.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IDirectSoundFullDuplex, @ptrCast(self)), pCaptureGuid, pRenderGuid, lpDscBufferDesc, lpDsBufferDesc, hWnd, dwLevel, lplpDirectSoundCaptureBuffer8, lplpDirectSoundBuffer8);
            }
        };
    }
    pub usingnamespace MethodMixin(@This());
};

//--------------------------------------------------------------------------------
// Section: Functions (10)
//--------------------------------------------------------------------------------
pub extern "dsound" fn DirectSoundCreate(
    pcGuidDevice: ?*const Guid,
    ppDS: ?*?*IDirectSound,
    pUnkOuter: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "dsound" fn DirectSoundEnumerateA(
    pDSEnumCallback: ?LPDSENUMCALLBACKA,
    pContext: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "dsound" fn DirectSoundEnumerateW(
    pDSEnumCallback: ?LPDSENUMCALLBACKW,
    pContext: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "dsound" fn DirectSoundCaptureCreate(
    pcGuidDevice: ?*const Guid,
    ppDSC: ?*?*IDirectSoundCapture,
    pUnkOuter: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "dsound" fn DirectSoundCaptureEnumerateA(
    pDSEnumCallback: ?LPDSENUMCALLBACKA,
    pContext: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "dsound" fn DirectSoundCaptureEnumerateW(
    pDSEnumCallback: ?LPDSENUMCALLBACKW,
    pContext: ?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "dsound" fn DirectSoundCreate8(
    pcGuidDevice: ?*const Guid,
    ppDS8: ?*?*IDirectSound8,
    pUnkOuter: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "dsound" fn DirectSoundCaptureCreate8(
    pcGuidDevice: ?*const Guid,
    ppDSC8: ?*?*IDirectSoundCapture,
    pUnkOuter: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "dsound" fn DirectSoundFullDuplexCreate(
    pcGuidCaptureDevice: ?*const Guid,
    pcGuidRenderDevice: ?*const Guid,
    pcDSCBufferDesc: ?*DSCBUFFERDESC,
    pcDSBufferDesc: ?*DSBUFFERDESC,
    hWnd: ?HWND,
    dwLevel: u32,
    ppDSFD: ?*?*IDirectSoundFullDuplex,
    ppDSCBuffer8: ?*?*IDirectSoundCaptureBuffer8,
    ppDSBuffer8: ?*?*IDirectSoundBuffer8,
    pUnkOuter: ?*IUnknown,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

pub extern "dsound" fn GetDeviceID(
    pGuidSrc: ?*const Guid,
    pGuidDest: ?*Guid,
) callconv(@import("std").os.windows.WINAPI) HRESULT;

//--------------------------------------------------------------------------------
// Section: Unicode Aliases (3)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../../zig.zig").unicode_mode) {
    .ansi => struct {
        pub const LPDSENUMCALLBACK = thismodule.LPDSENUMCALLBACKA;
        pub const DirectSoundEnumerate = thismodule.DirectSoundEnumerateA;
        pub const DirectSoundCaptureEnumerate = thismodule.DirectSoundCaptureEnumerateA;
    },
    .wide => struct {
        pub const LPDSENUMCALLBACK = thismodule.LPDSENUMCALLBACKW;
        pub const DirectSoundEnumerate = thismodule.DirectSoundEnumerateW;
        pub const DirectSoundCaptureEnumerate = thismodule.DirectSoundCaptureEnumerateW;
    },
    .unspecified => if (@import("builtin").is_test) struct {
        pub const LPDSENUMCALLBACK = *opaque {};
        pub const DirectSoundEnumerate = *opaque {};
        pub const DirectSoundCaptureEnumerate = *opaque {};
    } else struct {
        pub const LPDSENUMCALLBACK = @compileError("'LPDSENUMCALLBACK' requires that UNICODE be set to true or false in the root module");
        pub const DirectSoundEnumerate = @compileError("'DirectSoundEnumerate' requires that UNICODE be set to true or false in the root module");
        pub const DirectSoundCaptureEnumerate = @compileError("'DirectSoundCaptureEnumerate' requires that UNICODE be set to true or false in the root module");
    },
};
//--------------------------------------------------------------------------------
// Section: Imports (10)
//--------------------------------------------------------------------------------
const Guid = @import("../../zig.zig").Guid;
const BOOL = @import("../../foundation.zig").BOOL;
const D3DVECTOR = @import("../../graphics/direct3d.zig").D3DVECTOR;
const HANDLE = @import("../../foundation.zig").HANDLE;
const HRESULT = @import("../../foundation.zig").HRESULT;
const HWND = @import("../../foundation.zig").HWND;
const IUnknown = @import("../../system/com.zig").IUnknown;
const PSTR = @import("../../foundation.zig").PSTR;
const PWSTR = @import("../../foundation.zig").PWSTR;
const WAVEFORMATEX = @import("../../media/audio.zig").WAVEFORMATEX;

test {
    // The following '_ = <FuncPtrType>' lines are a workaround for https://github.com/ziglang/zig/issues/4476
    if (@hasDecl(@This(), "LPDSENUMCALLBACKA")) {
        _ = LPDSENUMCALLBACKA;
    }
    if (@hasDecl(@This(), "LPDSENUMCALLBACKW")) {
        _ = LPDSENUMCALLBACKW;
    }

    @setEvalBranchQuota(comptime @import("std").meta.declarations(@This()).len * 3);

    // reference all the pub declarations
    if (!@import("builtin").is_test) return;
    inline for (comptime @import("std").meta.declarations(@This())) |decl| {
        if (decl.is_pub) {
            _ = @field(@This(), decl.name);
        }
    }
}
