obs-ws-sdk 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1463 @@
+import OBSWebSocket from 'obs-websocket-js';
+export { default as OBSWebSocket } from 'obs-websocket-js';
+import { z } from 'zod/v4';
+
+class BaseModule {
+  constructor(obs) {
+    this.obs = obs;
+  }
+}
+const jsonObjectSchema = z.record(z.string(), z.json());
+
+const GetPersistentDataRequestSchema = z.object({
+  realm: z.string(),
+  slotName: z.string()
+});
+const SetPersistentDataRequestSchema = z.object({
+  realm: z.string(),
+  slotName: z.string(),
+  slotValue: z.json()
+});
+const SetCurrentSceneCollectionRequestSchema = z.object({
+  sceneCollectionName: z.string()
+});
+const CreateSceneCollectionRequestSchema = z.object({
+  sceneCollectionName: z.string()
+});
+const SetCurrentProfileRequestSchema = z.object({
+  profileName: z.string()
+});
+const CreateProfileRequestSchema = z.object({
+  profileName: z.string()
+});
+const RemoveProfileRequestSchema = z.object({
+  profileName: z.string()
+});
+const GetProfileParameterRequestSchema = z.object({
+  parameterCategory: z.string(),
+  parameterName: z.string()
+});
+const SetProfileParameterRequestSchema = z.object({
+  parameterCategory: z.string(),
+  parameterName: z.string(),
+  parameterValue: z.string()
+});
+const SetVideoSettingsRequestSchema = z.object({
+  fpsNumerator: z.number().min(1).optional(),
+  fpsDenominator: z.number().min(1).optional(),
+  baseWidth: z.number().min(1).max(4096).optional(),
+  baseHeight: z.number().min(1).max(4096).optional(),
+  outputWidth: z.number().min(1).max(4096).optional(),
+  outputHeight: z.number().min(1).max(4096).optional()
+});
+const SetStreamServiceSettingsRequestSchema = z.object({
+  streamServiceType: z.string(),
+  streamServiceSettings: jsonObjectSchema
+});
+const SetRecordDirectoryRequestSchema = z.object({
+  recordDirectory: z.string()
+});
+const GetPersistentDataResponseSchema = z.object({
+  slotValue: z.json()
+});
+const GetSceneCollectionListResponseSchema = z.object({
+  currentSceneCollectionName: z.string(),
+  sceneCollections: z.string().array()
+});
+const GetProfileListResponseSchema = z.object({
+  currentProfileName: z.string(),
+  profiles: z.string().array()
+});
+const GetProfileParameterResponseSchema = z.object({
+  parameterValue: z.string().nullable(),
+  defaultParameterValue: z.string().nullable()
+});
+const GetVideoSettingsResponseSchema = z.object({
+  fpsNumerator: z.number(),
+  fpsDenominator: z.number(),
+  baseWidth: z.number(),
+  baseHeight: z.number(),
+  outputWidth: z.number(),
+  outputHeight: z.number()
+});
+const GetStreamServiceSettingsResponseSchema = z.object({
+  streamServiceType: z.string(),
+  streamServiceSettings: jsonObjectSchema
+});
+const GetRecordDirectoryResponseSchema = z.object({
+  recordDirectory: z.string()
+});
+class ConfigModule extends BaseModule {
+  async getPersistentData(params) {
+    GetPersistentDataRequestSchema.parse(params);
+    const res = await this.obs.call("GetPersistentData", params);
+    return GetPersistentDataResponseSchema.parse(res);
+  }
+  async setPersistentData(params) {
+    SetPersistentDataRequestSchema.parse(params);
+    await this.obs.call("SetPersistentData", params);
+  }
+  async getSceneCollectionList() {
+    const res = await this.obs.call("GetSceneCollectionList");
+    return GetSceneCollectionListResponseSchema.parse(res);
+  }
+  async setCurrentSceneCollection(params) {
+    SetCurrentSceneCollectionRequestSchema.parse(params);
+    await this.obs.call("SetCurrentSceneCollection", params);
+  }
+  async createSceneCollection(params) {
+    CreateSceneCollectionRequestSchema.parse(params);
+    await this.obs.call("CreateSceneCollection", params);
+  }
+  async getProfileList() {
+    const res = await this.obs.call("GetProfileList");
+    return GetProfileListResponseSchema.parse(res);
+  }
+  async setCurrentProfile(params) {
+    SetCurrentProfileRequestSchema.parse(params);
+    await this.obs.call("SetCurrentProfile", params);
+  }
+  async createProfile(params) {
+    CreateProfileRequestSchema.parse(params);
+    await this.obs.call("CreateProfile", params);
+  }
+  async removeProfile(params) {
+    RemoveProfileRequestSchema.parse(params);
+    await this.obs.call("RemoveProfile", params);
+  }
+  async getProfileParameter(params) {
+    GetProfileParameterRequestSchema.parse(params);
+    const res = await this.obs.call("GetProfileParameter", params);
+    return GetProfileParameterResponseSchema.parse(res);
+  }
+  async setProfileParameter(params) {
+    SetProfileParameterRequestSchema.parse(params);
+    await this.obs.call("SetProfileParameter", params);
+  }
+  async getVideoSettings() {
+    const res = await this.obs.call("GetVideoSettings");
+    return GetVideoSettingsResponseSchema.parse(res);
+  }
+  async setVideoSettings(params) {
+    SetVideoSettingsRequestSchema.parse(params);
+    await this.obs.call("SetVideoSettings", params);
+  }
+  async getStreamServiceSettings() {
+    const res = await this.obs.call("GetStreamServiceSettings");
+    return GetStreamServiceSettingsResponseSchema.parse(res);
+  }
+  async setStreamServiceSettings(params) {
+    SetStreamServiceSettingsRequestSchema.parse(params);
+    await this.obs.call("SetStreamServiceSettings", params);
+  }
+  async getRecordDirectory() {
+    const res = await this.obs.call("GetRecordDirectory");
+    return GetRecordDirectoryResponseSchema.parse(res);
+  }
+  async setRecordDirectory(params) {
+    SetRecordDirectoryRequestSchema.parse(params);
+    await this.obs.call("SetRecordDirectory", params);
+  }
+}
+
+const GetSourceFilterListRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sourceName: z.string().optional(),
+  sourceUuid: z.string().optional()
+});
+const GetSourceFilterDefaultSettingsRequestSchema = z.object({
+  filterKind: z.string()
+});
+const CreateSourceFilterRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sourceName: z.string().optional(),
+  sourceUuid: z.string().optional(),
+  filterName: z.string(),
+  filterKind: z.string(),
+  filterSettings: jsonObjectSchema.optional()
+});
+const RemoveSourceFilterRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sourceName: z.string().optional(),
+  sourceUuid: z.string().optional(),
+  filterName: z.string()
+});
+const SetSourceFilterNameRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sourceName: z.string().optional(),
+  sourceUuid: z.string().optional(),
+  filterName: z.string(),
+  newFilterName: z.string()
+});
+const GetSourceFilterRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sourceName: z.string().optional(),
+  sourceUuid: z.string().optional(),
+  filterName: z.string()
+});
+const SetSourceFilterIndexRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sourceName: z.string().optional(),
+  sourceUuid: z.string().optional(),
+  filterName: z.string(),
+  filterIndex: z.number().min(0)
+});
+const SetSourceFilterSettingsRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sourceName: z.string().optional(),
+  sourceUuid: z.string().optional(),
+  filterName: z.string(),
+  filterSettings: jsonObjectSchema,
+  overlay: z.boolean().optional()
+});
+const SetSourceFilterEnabledRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sourceName: z.string().optional(),
+  sourceUuid: z.string().optional(),
+  filterName: z.string(),
+  filterEnabled: z.boolean()
+});
+const GetSourceFilterKindListResponseSchema = z.object({
+  sourceFilterKinds: z.string().array()
+});
+const GetSourceFilterListResponseSchema = z.object({
+  filters: jsonObjectSchema.array()
+});
+const GetSourceFilterDefaultSettingsResponseSchema = z.object({
+  defaultFilterSettings: jsonObjectSchema
+});
+const GetSourceFilterResponseSchema = z.object({
+  filterEnabled: z.boolean(),
+  filterIndex: z.number(),
+  filterKind: z.string(),
+  filterName: z.string(),
+  filterSettings: jsonObjectSchema
+});
+class FiltersModule extends BaseModule {
+  async getSourceFilterKindList() {
+    const res = await this.obs.call("GetSourceFilterKindList");
+    return GetSourceFilterKindListResponseSchema.parse(res);
+  }
+  async getSourceFilterList(params) {
+    GetSourceFilterListRequestSchema.parse(params);
+    const res = await this.obs.call("GetSourceFilterList", params);
+    return GetSourceFilterListResponseSchema.parse(res);
+  }
+  async getSourceFilterDefaultSettings(params) {
+    GetSourceFilterDefaultSettingsRequestSchema.parse(params);
+    const res = await this.obs.call("GetSourceFilterDefaultSettings", params);
+    return GetSourceFilterDefaultSettingsResponseSchema.parse(res);
+  }
+  async createSourceFilter(params) {
+    CreateSourceFilterRequestSchema.parse(params);
+    await this.obs.call("CreateSourceFilter", params);
+  }
+  async removeSourceFilter(params) {
+    RemoveSourceFilterRequestSchema.parse(params);
+    await this.obs.call("RemoveSourceFilter", params);
+  }
+  async setSourceFilterName(params) {
+    SetSourceFilterNameRequestSchema.parse(params);
+    await this.obs.call("SetSourceFilterName", params);
+  }
+  async getSourceFilter(params) {
+    GetSourceFilterRequestSchema.parse(params);
+    const res = await this.obs.call("GetSourceFilter", params);
+    return GetSourceFilterResponseSchema.parse(res);
+  }
+  async setSourceFilterIndex(params) {
+    SetSourceFilterIndexRequestSchema.parse(params);
+    await this.obs.call("SetSourceFilterIndex", params);
+  }
+  async setSourceFilterSettings(params) {
+    SetSourceFilterSettingsRequestSchema.parse(params);
+    await this.obs.call("SetSourceFilterSettings", params);
+  }
+  async setSourceFilterEnabled(params) {
+    SetSourceFilterEnabledRequestSchema.parse(params);
+    await this.obs.call("SetSourceFilterEnabled", params);
+  }
+}
+
+const GetVersionResponseSchema = z.object({
+  obsVersion: z.string(),
+  obsWebSocketVersion: z.string(),
+  rpcVersion: z.number(),
+  availableRequests: z.string().array(),
+  supportedImageFormats: z.string().array(),
+  platform: z.string(),
+  platformDescription: z.string()
+});
+const numOrNaN = z.union([z.number(), z.nan()]);
+const GetStatsResponseSchema = z.object({
+  cpuUsage: numOrNaN,
+  memoryUsage: numOrNaN,
+  availableDiskSpace: numOrNaN,
+  activeFps: numOrNaN,
+  averageFrameRenderTime: numOrNaN,
+  renderSkippedFrames: numOrNaN,
+  renderTotalFrames: numOrNaN,
+  outputSkippedFrames: numOrNaN,
+  outputTotalFrames: numOrNaN,
+  webSocketSessionIncomingMessages: numOrNaN,
+  webSocketSessionOutgoingMessages: numOrNaN
+});
+const BroadcastCustomEventRequestSchema = z.object({
+  eventData: jsonObjectSchema
+});
+const CallVendorRequestRequestSchema = z.object({
+  vendorName: z.string(),
+  requestType: z.string(),
+  requestData: jsonObjectSchema.optional()
+});
+const CallVendorRequestResponseSchema = z.object({
+  vendorName: z.string(),
+  requestType: z.string(),
+  responseData: jsonObjectSchema
+});
+const GetHotkeyListResponseSchema = z.object({
+  hotkeys: z.string().array()
+});
+const TriggerHotkeyByNameRequestSchema = z.object({
+  hotkeyName: z.string(),
+  contextName: z.string().optional()
+});
+const TriggerHotkeyByKeySequenceRequestSchema = z.object({
+  keyId: z.string().optional(),
+  keyModifiers: z.object({
+    shift: z.boolean().optional(),
+    control: z.boolean().optional(),
+    alt: z.boolean().optional(),
+    command: z.boolean().optional()
+  }).optional()
+});
+class GeneralModule extends BaseModule {
+  async getVersion() {
+    const res = await this.obs.call("GetVersion");
+    return GetVersionResponseSchema.parse(res);
+  }
+  async getStats() {
+    const res = await this.obs.call("GetStats");
+    return GetStatsResponseSchema.parse(res);
+  }
+  async broadcastCustomEvent(params) {
+    BroadcastCustomEventRequestSchema.parse(params);
+    await this.obs.call("BroadcastCustomEvent", params);
+  }
+  async callVendorRequest(params) {
+    CallVendorRequestRequestSchema.parse(params);
+    const res = await this.obs.call("CallVendorRequest", params);
+    return CallVendorRequestResponseSchema.parse(res);
+  }
+  async getHotkeyList() {
+    const res = await this.obs.call("GetHotkeyList");
+    return GetHotkeyListResponseSchema.parse(res);
+  }
+  async triggerHotkeyByName(params) {
+    TriggerHotkeyByNameRequestSchema.parse(params);
+    await this.obs.call("TriggerHotkeyByName", params);
+  }
+  async triggerHotkeyByKeySequence(params) {
+    TriggerHotkeyByKeySequenceRequestSchema.parse(params);
+    await this.obs.call("TriggerHotkeyByKeySequence", params);
+  }
+}
+
+const GetInputListRequestSchema = z.object({
+  inputKind: z.string().optional()
+});
+const GetInputKindListRequestSchema = z.object({
+  unversioned: z.boolean().optional()
+});
+const CreateInputRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sceneName: z.string().optional(),
+  sceneUuid: z.string().optional(),
+  inputName: z.string(),
+  inputKind: z.string(),
+  inputSettings: jsonObjectSchema.optional(),
+  sceneItemEnabled: z.boolean().optional()
+});
+const RemoveInputRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const SetInputNameRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  newInputName: z.string()
+});
+const GetInputDefaultSettingsRequestSchema = z.object({
+  inputKind: z.string()
+});
+const GetInputSettingsRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const SetInputSettingsRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  inputSettings: jsonObjectSchema,
+  overlay: z.boolean().optional()
+});
+const GetInputMuteRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const SetInputMuteRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  inputMuted: z.boolean()
+});
+const ToggleInputMuteRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const GetInputVolumeRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const SetInputVolumeRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  inputVolumeMul: z.number().min(0).max(20).optional(),
+  inputVolumeDb: z.number().min(-100).max(26).optional()
+});
+const GetInputAudioBalanceRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const SetInputAudioBalanceRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  inputAudioBalance: z.number().min(0).max(1)
+});
+const GetInputAudioSyncOffsetRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const SetInputAudioSyncOffsetRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  inputAudioSyncOffset: z.number().min(-950).max(2e4)
+});
+const GetInputAudioMonitorTypeRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const SetInputAudioMonitorTypeRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  monitorType: z.string()
+});
+const GetInputAudioTracksRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const SetInputAudioTracksRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  inputAudioTracks: jsonObjectSchema
+});
+const GetInputDeinterlaceModeRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const SetInputDeinterlaceModeRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  inputDeinterlaceMode: z.string()
+});
+const GetInputDeinterlaceFieldOrderRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const SetInputDeinterlaceFieldOrderRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  inputDeinterlaceFieldOrder: z.string()
+});
+const GetInputPropertiesListPropertyItemsRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  propertyName: z.string()
+});
+const PressInputPropertiesButtonRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  propertyName: z.string()
+});
+const GetInputListResponseSchema = z.object({
+  inputs: jsonObjectSchema.array()
+});
+const GetInputKindListResponseSchema = z.object({
+  inputKinds: z.string().array()
+});
+const GetSpecialInputsResponseSchema = z.object({
+  desktop1: z.string().nullable(),
+  desktop2: z.string().nullable(),
+  mic1: z.string().nullable(),
+  mic2: z.string().nullable(),
+  mic3: z.string().nullable(),
+  mic4: z.string().nullable()
+});
+const CreateInputResponseSchema = z.object({
+  inputUuid: z.string(),
+  sceneItemId: z.number()
+});
+const GetInputDefaultSettingsResponseSchema = z.object({
+  defaultInputSettings: jsonObjectSchema
+});
+const GetInputSettingsResponseSchema = z.object({
+  inputSettings: jsonObjectSchema,
+  inputKind: z.string()
+});
+const GetInputMuteResponseSchema = z.object({
+  inputMuted: z.boolean()
+});
+const ToggleInputMuteResponseSchema = z.object({
+  inputMuted: z.boolean()
+});
+const GetInputVolumeResponseSchema = z.object({
+  inputVolumeMul: z.number(),
+  inputVolumeDb: z.number()
+});
+const GetInputAudioBalanceResponseSchema = z.object({
+  inputAudioBalance: z.number()
+});
+const GetInputAudioSyncOffsetResponseSchema = z.object({
+  inputAudioSyncOffset: z.number()
+});
+const GetInputAudioMonitorTypeResponseSchema = z.object({
+  monitorType: z.string()
+});
+const GetInputAudioTracksResponseSchema = z.object({
+  inputAudioTracks: jsonObjectSchema
+});
+const GetInputDeinterlaceModeResponseSchema = z.object({
+  inputDeinterlaceMode: z.string()
+});
+const GetInputDeinterlaceFieldOrderResponseSchema = z.object({
+  inputDeinterlaceFieldOrder: z.string()
+});
+const GetInputPropertiesListPropertyItemsResponseSchema = z.object({
+  propertyItems: z.array(jsonObjectSchema)
+});
+class InputsModule extends BaseModule {
+  async getInputList(params) {
+    if (params) GetInputListRequestSchema.parse(params);
+    const res = await this.obs.call("GetInputList", params);
+    return GetInputListResponseSchema.parse(res);
+  }
+  async getInputKindList(params) {
+    if (params) GetInputKindListRequestSchema.parse(params);
+    const res = await this.obs.call("GetInputKindList", params);
+    return GetInputKindListResponseSchema.parse(res);
+  }
+  async getSpecialInputs() {
+    const res = await this.obs.call("GetSpecialInputs");
+    return GetSpecialInputsResponseSchema.parse(res);
+  }
+  async createInput(params) {
+    CreateInputRequestSchema.parse(params);
+    const res = await this.obs.call("CreateInput", params);
+    return CreateInputResponseSchema.parse(res);
+  }
+  async removeInput(params) {
+    RemoveInputRequestSchema.parse(params);
+    await this.obs.call("RemoveInput", params);
+  }
+  async setInputName(params) {
+    SetInputNameRequestSchema.parse(params);
+    await this.obs.call("SetInputName", params);
+  }
+  async getInputDefaultSettings(params) {
+    GetInputDefaultSettingsRequestSchema.parse(params);
+    const res = await this.obs.call("GetInputDefaultSettings", params);
+    return GetInputDefaultSettingsResponseSchema.parse(res);
+  }
+  async getInputSettings(params) {
+    GetInputSettingsRequestSchema.parse(params);
+    const res = await this.obs.call("GetInputSettings", params);
+    return GetInputSettingsResponseSchema.parse(res);
+  }
+  async setInputSettings(params) {
+    SetInputSettingsRequestSchema.parse(params);
+    await this.obs.call("SetInputSettings", params);
+  }
+  async getInputMute(params) {
+    GetInputMuteRequestSchema.parse(params);
+    const res = await this.obs.call("GetInputMute", params);
+    return GetInputMuteResponseSchema.parse(res);
+  }
+  async setInputMute(params) {
+    SetInputMuteRequestSchema.parse(params);
+    await this.obs.call("SetInputMute", params);
+  }
+  async toggleInputMute(params) {
+    ToggleInputMuteRequestSchema.parse(params);
+    const res = await this.obs.call("ToggleInputMute", params);
+    return ToggleInputMuteResponseSchema.parse(res);
+  }
+  async getInputVolume(params) {
+    GetInputVolumeRequestSchema.parse(params);
+    const res = await this.obs.call("GetInputVolume", params);
+    return GetInputVolumeResponseSchema.parse(res);
+  }
+  async setInputVolume(params) {
+    SetInputVolumeRequestSchema.parse(params);
+    await this.obs.call("SetInputVolume", params);
+  }
+  async getInputAudioBalance(params) {
+    GetInputAudioBalanceRequestSchema.parse(params);
+    const res = await this.obs.call("GetInputAudioBalance", params);
+    return GetInputAudioBalanceResponseSchema.parse(res);
+  }
+  async setInputAudioBalance(params) {
+    SetInputAudioBalanceRequestSchema.parse(params);
+    await this.obs.call("SetInputAudioBalance", params);
+  }
+  async getInputAudioSyncOffset(params) {
+    GetInputAudioSyncOffsetRequestSchema.parse(params);
+    const res = await this.obs.call("GetInputAudioSyncOffset", params);
+    return GetInputAudioSyncOffsetResponseSchema.parse(res);
+  }
+  async setInputAudioSyncOffset(params) {
+    SetInputAudioSyncOffsetRequestSchema.parse(params);
+    await this.obs.call("SetInputAudioSyncOffset", params);
+  }
+  async getInputAudioMonitorType(params) {
+    GetInputAudioMonitorTypeRequestSchema.parse(params);
+    const res = await this.obs.call("GetInputAudioMonitorType", params);
+    return GetInputAudioMonitorTypeResponseSchema.parse(res);
+  }
+  async setInputAudioMonitorType(params) {
+    SetInputAudioMonitorTypeRequestSchema.parse(params);
+    await this.obs.call("SetInputAudioMonitorType", params);
+  }
+  async getInputAudioTracks(params) {
+    GetInputAudioTracksRequestSchema.parse(params);
+    const res = await this.obs.call("GetInputAudioTracks", params);
+    return GetInputAudioTracksResponseSchema.parse(res);
+  }
+  async setInputAudioTracks(params) {
+    SetInputAudioTracksRequestSchema.parse(params);
+    await this.obs.call("SetInputAudioTracks", params);
+  }
+  async getInputDeinterlaceMode(params) {
+    GetInputDeinterlaceModeRequestSchema.parse(params);
+    const res = await this.obs.call("GetInputDeinterlaceMode", params);
+    return GetInputDeinterlaceModeResponseSchema.parse(res);
+  }
+  async setInputDeinterlaceMode(params) {
+    SetInputDeinterlaceModeRequestSchema.parse(params);
+    await this.obs.call("SetInputDeinterlaceMode", params);
+  }
+  async getInputDeinterlaceFieldOrder(params) {
+    GetInputDeinterlaceFieldOrderRequestSchema.parse(params);
+    const res = await this.obs.call("GetInputDeinterlaceFieldOrder", params);
+    return GetInputDeinterlaceFieldOrderResponseSchema.parse(res);
+  }
+  async setInputDeinterlaceFieldOrder(params) {
+    SetInputDeinterlaceFieldOrderRequestSchema.parse(params);
+    await this.obs.call("SetInputDeinterlaceFieldOrder", params);
+  }
+  async getInputPropertiesListPropertyItems(params) {
+    GetInputPropertiesListPropertyItemsRequestSchema.parse(params);
+    const res = await this.obs.call("GetInputPropertiesListPropertyItems", params);
+    return GetInputPropertiesListPropertyItemsResponseSchema.parse(res);
+  }
+  async pressInputPropertiesButton(params) {
+    PressInputPropertiesButtonRequestSchema.parse(params);
+    await this.obs.call("PressInputPropertiesButton", params);
+  }
+}
+
+const GetMediaInputStatusRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const SetMediaInputCursorRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  mediaCursor: z.number().min(0)
+});
+const OffsetMediaInputCursorRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  mediaCursorOffset: z.number()
+});
+const TriggerMediaInputActionRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional(),
+  mediaAction: z.string()
+});
+const GetMediaInputStatusResponseSchema = z.object({
+  mediaState: z.string(),
+  mediaDuration: z.number().nullable(),
+  mediaCursor: z.number().nullable()
+});
+class MediaInputsModule extends BaseModule {
+  async getMediaInputStatus(params) {
+    GetMediaInputStatusRequestSchema.parse(params);
+    const res = await this.obs.call("GetMediaInputStatus", params);
+    return GetMediaInputStatusResponseSchema.parse(res);
+  }
+  async setMediaInputCursor(params) {
+    SetMediaInputCursorRequestSchema.parse(params);
+    await this.obs.call("SetMediaInputCursor", params);
+  }
+  async offsetMediaInputCursor(params) {
+    OffsetMediaInputCursorRequestSchema.parse(params);
+    await this.obs.call("OffsetMediaInputCursor", params);
+  }
+  async triggerMediaInputAction(params) {
+    TriggerMediaInputActionRequestSchema.parse(params);
+    await this.obs.call("TriggerMediaInputAction", params);
+  }
+}
+
+const GetOutputStatusRequestSchema = z.object({
+  outputName: z.string()
+});
+const ToggleOutputRequestSchema = z.object({
+  outputName: z.string()
+});
+const StartOutputRequestSchema = z.object({
+  outputName: z.string()
+});
+const StopOutputRequestSchema = z.object({
+  outputName: z.string()
+});
+const GetOutputSettingsRequestSchema = z.object({
+  outputName: z.string()
+});
+const SetOutputSettingsRequestSchema = z.object({
+  outputName: z.string(),
+  outputSettings: jsonObjectSchema
+});
+const GetVirtualCamStatusResponseSchema = z.object({
+  outputActive: z.boolean()
+});
+const ToggleVirtualCamResponseSchema = z.object({
+  outputActive: z.boolean()
+});
+const GetReplayBufferStatusResponseSchema = z.object({
+  outputActive: z.boolean()
+});
+const ToggleReplayBufferResponseSchema = z.object({
+  outputActive: z.boolean()
+});
+const GetLastReplayBufferReplayResponseSchema = z.object({
+  savedReplayPath: z.string()
+});
+const GetOutputListResponseSchema = z.object({
+  outputs: jsonObjectSchema.array()
+});
+const GetOutputStatusResponseSchema = z.object({
+  outputActive: z.boolean(),
+  outputReconnecting: z.boolean(),
+  outputTimecode: z.string(),
+  outputDuration: z.number(),
+  outputCongestion: z.number(),
+  outputBytes: z.number(),
+  outputSkippedFrames: z.number(),
+  outputTotalFrames: z.number()
+});
+const ToggleOutputResponseSchema = z.object({
+  outputActive: z.boolean()
+});
+const GetOutputSettingsResponseSchema = z.object({
+  outputSettings: jsonObjectSchema
+});
+class OutputsModule extends BaseModule {
+  async getVirtualCamStatus() {
+    const res = await this.obs.call("GetVirtualCamStatus");
+    return GetVirtualCamStatusResponseSchema.parse(res);
+  }
+  async toggleVirtualCam() {
+    const res = await this.obs.call("ToggleVirtualCam");
+    return ToggleVirtualCamResponseSchema.parse(res);
+  }
+  async startVirtualCam() {
+    await this.obs.call("StartVirtualCam");
+  }
+  async stopVirtualCam() {
+    await this.obs.call("StopVirtualCam");
+  }
+  async getReplayBufferStatus() {
+    const res = await this.obs.call("GetReplayBufferStatus");
+    return GetReplayBufferStatusResponseSchema.parse(res);
+  }
+  async toggleReplayBuffer() {
+    const res = await this.obs.call("ToggleReplayBuffer");
+    return ToggleReplayBufferResponseSchema.parse(res);
+  }
+  async startReplayBuffer() {
+    await this.obs.call("StartReplayBuffer");
+  }
+  async stopReplayBuffer() {
+    await this.obs.call("StopReplayBuffer");
+  }
+  async saveReplayBuffer() {
+    await this.obs.call("SaveReplayBuffer");
+  }
+  async getLastReplayBufferReplay() {
+    const res = await this.obs.call("GetLastReplayBufferReplay");
+    return GetLastReplayBufferReplayResponseSchema.parse(res);
+  }
+  async getOutputList() {
+    const res = await this.obs.call("GetOutputList");
+    return GetOutputListResponseSchema.parse(res);
+  }
+  async getOutputStatus(params) {
+    GetOutputStatusRequestSchema.parse(params);
+    const res = await this.obs.call("GetOutputStatus", params);
+    return GetOutputStatusResponseSchema.parse(res);
+  }
+  async toggleOutput(params) {
+    ToggleOutputRequestSchema.parse(params);
+    const res = await this.obs.call("ToggleOutput", params);
+    return ToggleOutputResponseSchema.parse(res);
+  }
+  async startOutput(params) {
+    StartOutputRequestSchema.parse(params);
+    await this.obs.call("StartOutput", params);
+  }
+  async stopOutput(params) {
+    StopOutputRequestSchema.parse(params);
+    await this.obs.call("StopOutput", params);
+  }
+  async getOutputSettings(params) {
+    GetOutputSettingsRequestSchema.parse(params);
+    const res = await this.obs.call("GetOutputSettings", params);
+    return GetOutputSettingsResponseSchema.parse(res);
+  }
+  async setOutputSettings(params) {
+    SetOutputSettingsRequestSchema.parse(params);
+    await this.obs.call("SetOutputSettings", params);
+  }
+}
+
+const CreateRecordChapterRequestSchema = z.object({
+  chapterName: z.string().optional()
+});
+const GetRecordStatusResponseSchema = z.object({
+  outputActive: z.boolean(),
+  outputPaused: z.boolean(),
+  outputTimecode: z.string(),
+  outputDuration: z.number(),
+  outputBytes: z.number()
+});
+const ToggleRecordResponseSchema = z.object({
+  outputActive: z.boolean()
+});
+const StopRecordResponseSchema = z.object({
+  outputPath: z.string()
+});
+class RecordModule extends BaseModule {
+  async getRecordStatus() {
+    const res = await this.obs.call("GetRecordStatus");
+    return GetRecordStatusResponseSchema.parse(res);
+  }
+  async toggleRecord() {
+    const res = await this.obs.call("ToggleRecord");
+    return ToggleRecordResponseSchema.parse(res);
+  }
+  async startRecord() {
+    await this.obs.call("StartRecord");
+  }
+  async stopRecord() {
+    const res = await this.obs.call("StopRecord");
+    return StopRecordResponseSchema.parse(res);
+  }
+  async toggleRecordPause() {
+    await this.obs.call("ToggleRecordPause");
+  }
+  async pauseRecord() {
+    await this.obs.call("PauseRecord");
+  }
+  async resumeRecord() {
+    await this.obs.call("ResumeRecord");
+  }
+  async splitRecordFile() {
+    await this.obs.call("SplitRecordFile");
+  }
+  async createRecordChapter(params) {
+    if (params) CreateRecordChapterRequestSchema.parse(params);
+    await this.obs.call("CreateRecordChapter", params);
+  }
+}
+
+const SceneRefSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sceneName: z.string().optional(),
+  sceneUuid: z.string().optional()
+});
+const SceneItemRefSchema = SceneRefSchema.extend({
+  sceneItemId: z.number().min(0)
+});
+const GetSceneItemListRequestSchema = SceneRefSchema;
+const GetGroupSceneItemListRequestSchema = SceneRefSchema;
+const GetSceneItemIdRequestSchema = SceneRefSchema.extend({
+  sourceName: z.string(),
+  searchOffset: z.number().min(-1).optional()
+});
+const GetSceneItemSourceRequestSchema = SceneItemRefSchema;
+const CreateSceneItemRequestSchema = SceneRefSchema.extend({
+  sourceName: z.string().optional(),
+  sourceUuid: z.string().optional(),
+  sceneItemEnabled: z.boolean().optional()
+});
+const RemoveSceneItemRequestSchema = SceneItemRefSchema;
+const DuplicateSceneItemRequestSchema = SceneItemRefSchema.extend({
+  destinationSceneName: z.string().optional(),
+  destinationSceneUuid: z.string().optional()
+});
+const GetSceneItemTransformRequestSchema = SceneItemRefSchema;
+const SetSceneItemTransformRequestSchema = SceneItemRefSchema.extend({
+  sceneItemTransform: jsonObjectSchema
+});
+const GetSceneItemEnabledRequestSchema = SceneItemRefSchema;
+const SetSceneItemEnabledRequestSchema = SceneItemRefSchema.extend({
+  sceneItemEnabled: z.boolean()
+});
+const GetSceneItemLockedRequestSchema = SceneItemRefSchema;
+const SetSceneItemLockedRequestSchema = SceneItemRefSchema.extend({
+  sceneItemLocked: z.boolean()
+});
+const GetSceneItemIndexRequestSchema = SceneItemRefSchema;
+const SetSceneItemIndexRequestSchema = SceneItemRefSchema.extend({
+  sceneItemIndex: z.number().min(0)
+});
+const GetSceneItemBlendModeRequestSchema = SceneItemRefSchema;
+const SetSceneItemBlendModeRequestSchema = SceneItemRefSchema.extend({
+  sceneItemBlendMode: z.string()
+});
+const GetSceneItemListResponseSchema = z.object({
+  sceneItems: jsonObjectSchema.array()
+});
+const GetGroupSceneItemListResponseSchema = z.object({
+  sceneItems: jsonObjectSchema.array()
+});
+const GetSceneItemIdResponseSchema = z.object({
+  sceneItemId: z.number()
+});
+const GetSceneItemSourceResponseSchema = z.object({
+  sourceName: z.string(),
+  sourceUuid: z.string()
+});
+const CreateSceneItemResponseSchema = z.object({
+  sceneItemId: z.number()
+});
+const DuplicateSceneItemResponseSchema = z.object({
+  sceneItemId: z.number()
+});
+const GetSceneItemTransformResponseSchema = z.object({
+  sceneItemTransform: jsonObjectSchema
+});
+const GetSceneItemEnabledResponseSchema = z.object({
+  sceneItemEnabled: z.boolean()
+});
+const GetSceneItemLockedResponseSchema = z.object({
+  sceneItemLocked: z.boolean()
+});
+const GetSceneItemIndexResponseSchema = z.object({
+  sceneItemIndex: z.number()
+});
+const GetSceneItemBlendModeResponseSchema = z.object({
+  sceneItemBlendMode: z.string()
+});
+class SceneItemsModule extends BaseModule {
+  async getSceneItemList(params) {
+    GetSceneItemListRequestSchema.parse(params);
+    const res = await this.obs.call("GetSceneItemList", params);
+    return GetSceneItemListResponseSchema.parse(res);
+  }
+  async getGroupSceneItemList(params) {
+    GetGroupSceneItemListRequestSchema.parse(params);
+    const res = await this.obs.call("GetGroupSceneItemList", params);
+    return GetGroupSceneItemListResponseSchema.parse(res);
+  }
+  async getSceneItemId(params) {
+    GetSceneItemIdRequestSchema.parse(params);
+    const res = await this.obs.call("GetSceneItemId", params);
+    return GetSceneItemIdResponseSchema.parse(res);
+  }
+  async getSceneItemSource(params) {
+    GetSceneItemSourceRequestSchema.parse(params);
+    const res = await this.obs.call("GetSceneItemSource", params);
+    return GetSceneItemSourceResponseSchema.parse(res);
+  }
+  async createSceneItem(params) {
+    CreateSceneItemRequestSchema.parse(params);
+    const res = await this.obs.call("CreateSceneItem", params);
+    return CreateSceneItemResponseSchema.parse(res);
+  }
+  async removeSceneItem(params) {
+    RemoveSceneItemRequestSchema.parse(params);
+    await this.obs.call("RemoveSceneItem", params);
+  }
+  async duplicateSceneItem(params) {
+    DuplicateSceneItemRequestSchema.parse(params);
+    const res = await this.obs.call("DuplicateSceneItem", params);
+    return DuplicateSceneItemResponseSchema.parse(res);
+  }
+  async getSceneItemTransform(params) {
+    GetSceneItemTransformRequestSchema.parse(params);
+    const res = await this.obs.call("GetSceneItemTransform", params);
+    return GetSceneItemTransformResponseSchema.parse(res);
+  }
+  async setSceneItemTransform(params) {
+    SetSceneItemTransformRequestSchema.parse(params);
+    await this.obs.call("SetSceneItemTransform", params);
+  }
+  async getSceneItemEnabled(params) {
+    GetSceneItemEnabledRequestSchema.parse(params);
+    const res = await this.obs.call("GetSceneItemEnabled", params);
+    return GetSceneItemEnabledResponseSchema.parse(res);
+  }
+  async setSceneItemEnabled(params) {
+    SetSceneItemEnabledRequestSchema.parse(params);
+    await this.obs.call("SetSceneItemEnabled", params);
+  }
+  async getSceneItemLocked(params) {
+    GetSceneItemLockedRequestSchema.parse(params);
+    const res = await this.obs.call("GetSceneItemLocked", params);
+    return GetSceneItemLockedResponseSchema.parse(res);
+  }
+  async setSceneItemLocked(params) {
+    SetSceneItemLockedRequestSchema.parse(params);
+    await this.obs.call("SetSceneItemLocked", params);
+  }
+  async getSceneItemIndex(params) {
+    GetSceneItemIndexRequestSchema.parse(params);
+    const res = await this.obs.call("GetSceneItemIndex", params);
+    return GetSceneItemIndexResponseSchema.parse(res);
+  }
+  async setSceneItemIndex(params) {
+    SetSceneItemIndexRequestSchema.parse(params);
+    await this.obs.call("SetSceneItemIndex", params);
+  }
+  async getSceneItemBlendMode(params) {
+    GetSceneItemBlendModeRequestSchema.parse(params);
+    const res = await this.obs.call("GetSceneItemBlendMode", params);
+    return GetSceneItemBlendModeResponseSchema.parse(res);
+  }
+  async setSceneItemBlendMode(params) {
+    SetSceneItemBlendModeRequestSchema.parse(params);
+    await this.obs.call("SetSceneItemBlendMode", params);
+  }
+}
+
+const GetSceneListRequestSchema = z.object({
+  canvasUuid: z.string().optional()
+});
+const SetCurrentProgramSceneRequestSchema = z.object({
+  sceneName: z.string().optional(),
+  sceneUuid: z.string().optional()
+});
+const SetCurrentPreviewSceneRequestSchema = z.object({
+  sceneName: z.string().optional(),
+  sceneUuid: z.string().optional()
+});
+const CreateSceneRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sceneName: z.string()
+});
+const RemoveSceneRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sceneName: z.string().optional(),
+  sceneUuid: z.string().optional()
+});
+const SetSceneNameRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sceneName: z.string().optional(),
+  sceneUuid: z.string().optional(),
+  newSceneName: z.string()
+});
+const GetSceneSceneTransitionOverrideRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sceneName: z.string().optional(),
+  sceneUuid: z.string().optional()
+});
+const SetSceneSceneTransitionOverrideRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sceneName: z.string().optional(),
+  sceneUuid: z.string().optional(),
+  transitionName: z.string().optional(),
+  transitionDuration: z.number().min(50).max(2e4).optional()
+});
+const GetSceneListResponseSchema = z.object({
+  currentProgramSceneName: z.string().nullable(),
+  currentProgramSceneUuid: z.string().nullable(),
+  currentPreviewSceneName: z.string().nullable(),
+  currentPreviewSceneUuid: z.string().nullable(),
+  scenes: jsonObjectSchema.array()
+});
+const GetGroupListResponseSchema = z.object({
+  groups: z.string().array()
+});
+const GetCurrentProgramSceneResponseSchema = z.object({
+  sceneName: z.string(),
+  sceneUuid: z.string(),
+  currentProgramSceneName: z.string(),
+  currentProgramSceneUuid: z.string()
+});
+const GetCurrentPreviewSceneResponseSchema = z.object({
+  sceneName: z.string(),
+  sceneUuid: z.string(),
+  currentPreviewSceneName: z.string(),
+  currentPreviewSceneUuid: z.string()
+});
+const CreateSceneResponseSchema = z.object({
+  sceneUuid: z.string()
+});
+const GetSceneSceneTransitionOverrideResponseSchema = z.object({
+  transitionName: z.string().nullable(),
+  transitionDuration: z.number().nullable()
+});
+class ScenesModule extends BaseModule {
+  async getSceneList(params) {
+    if (params) GetSceneListRequestSchema.parse(params);
+    const res = await this.obs.call("GetSceneList", params);
+    return GetSceneListResponseSchema.parse(res);
+  }
+  async getGroupList() {
+    const res = await this.obs.call("GetGroupList");
+    return GetGroupListResponseSchema.parse(res);
+  }
+  async getCurrentProgramScene() {
+    const res = await this.obs.call("GetCurrentProgramScene");
+    return GetCurrentProgramSceneResponseSchema.parse(res);
+  }
+  async setCurrentProgramScene(params) {
+    SetCurrentProgramSceneRequestSchema.parse(params);
+    await this.obs.call("SetCurrentProgramScene", params);
+  }
+  async getCurrentPreviewScene() {
+    const res = await this.obs.call("GetCurrentPreviewScene");
+    return GetCurrentPreviewSceneResponseSchema.parse(res);
+  }
+  async setCurrentPreviewScene(params) {
+    SetCurrentPreviewSceneRequestSchema.parse(params);
+    await this.obs.call("SetCurrentPreviewScene", params);
+  }
+  async createScene(params) {
+    CreateSceneRequestSchema.parse(params);
+    const res = await this.obs.call("CreateScene", params);
+    return CreateSceneResponseSchema.parse(res);
+  }
+  async removeScene(params) {
+    RemoveSceneRequestSchema.parse(params);
+    await this.obs.call("RemoveScene", params);
+  }
+  async setSceneName(params) {
+    SetSceneNameRequestSchema.parse(params);
+    await this.obs.call("SetSceneName", params);
+  }
+  async getSceneSceneTransitionOverride(params) {
+    GetSceneSceneTransitionOverrideRequestSchema.parse(params);
+    const res = await this.obs.call("GetSceneSceneTransitionOverride", params);
+    return GetSceneSceneTransitionOverrideResponseSchema.parse(res);
+  }
+  async setSceneSceneTransitionOverride(params) {
+    SetSceneSceneTransitionOverrideRequestSchema.parse(params);
+    await this.obs.call("SetSceneSceneTransitionOverride", params);
+  }
+}
+
+const GetSourceActiveRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sourceName: z.string().optional(),
+  sourceUuid: z.string().optional()
+});
+const GetSourceScreenshotRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sourceName: z.string().optional(),
+  sourceUuid: z.string().optional(),
+  imageFormat: z.string(),
+  imageWidth: z.number().min(8).max(4096).optional(),
+  imageHeight: z.number().min(8).max(4096).optional(),
+  imageCompressionQuality: z.number().min(-1).max(100).optional()
+});
+const SaveSourceScreenshotRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sourceName: z.string().optional(),
+  sourceUuid: z.string().optional(),
+  imageFormat: z.string(),
+  imageFilePath: z.string(),
+  imageWidth: z.number().min(8).max(4096).optional(),
+  imageHeight: z.number().min(8).max(4096).optional(),
+  imageCompressionQuality: z.number().min(-1).max(100).optional()
+});
+const GetSourceActiveResponseSchema = z.object({
+  videoActive: z.boolean(),
+  videoShowing: z.boolean()
+});
+const GetSourceScreenshotResponseSchema = z.object({
+  imageData: z.string()
+});
+const GetCanvasListResponseSchema = z.object({
+  canvases: jsonObjectSchema.array()
+});
+class SourcesModule extends BaseModule {
+  async getSourceActive(params) {
+    GetSourceActiveRequestSchema.parse(params);
+    const res = await this.obs.call("GetSourceActive", params);
+    return GetSourceActiveResponseSchema.parse(res);
+  }
+  async getSourceScreenshot(params) {
+    GetSourceScreenshotRequestSchema.parse(params);
+    const res = await this.obs.call("GetSourceScreenshot", params);
+    return GetSourceScreenshotResponseSchema.parse(res);
+  }
+  async saveSourceScreenshot(params) {
+    SaveSourceScreenshotRequestSchema.parse(params);
+    await this.obs.call("SaveSourceScreenshot", params);
+  }
+  async getCanvasList() {
+    const res = await this.obs.call("GetCanvasList");
+    return GetCanvasListResponseSchema.parse(res);
+  }
+}
+
+const SendStreamCaptionRequestSchema = z.object({
+  captionText: z.string()
+});
+const GetStreamStatusResponseSchema = z.object({
+  outputActive: z.boolean(),
+  outputReconnecting: z.boolean(),
+  outputTimecode: z.string(),
+  outputDuration: z.number(),
+  outputCongestion: z.number(),
+  outputBytes: z.number(),
+  outputSkippedFrames: z.number(),
+  outputTotalFrames: z.number()
+});
+const ToggleStreamResponseSchema = z.object({
+  outputActive: z.boolean()
+});
+class StreamModule extends BaseModule {
+  async getStreamStatus() {
+    const res = await this.obs.call("GetStreamStatus");
+    return GetStreamStatusResponseSchema.parse(res);
+  }
+  async toggleStream() {
+    const res = await this.obs.call("ToggleStream");
+    return ToggleStreamResponseSchema.parse(res);
+  }
+  async startStream() {
+    await this.obs.call("StartStream");
+  }
+  async stopStream() {
+    await this.obs.call("StopStream");
+  }
+  async sendStreamCaption(params) {
+    SendStreamCaptionRequestSchema.parse(params);
+    await this.obs.call("SendStreamCaption", params);
+  }
+}
+
+const SetCurrentSceneTransitionRequestSchema = z.object({
+  transitionName: z.string()
+});
+const SetCurrentSceneTransitionDurationRequestSchema = z.object({
+  transitionDuration: z.number().min(50).max(2e4)
+});
+const SetCurrentSceneTransitionSettingsRequestSchema = z.object({
+  transitionSettings: jsonObjectSchema,
+  overlay: z.boolean().optional()
+});
+const SetTBarPositionRequestSchema = z.object({
+  position: z.number().min(0).max(1),
+  release: z.boolean().optional()
+});
+const GetTransitionKindListResponseSchema = z.object({
+  transitionKinds: z.string().array()
+});
+const GetSceneTransitionListResponseSchema = z.object({
+  currentSceneTransitionName: z.string().nullable(),
+  currentSceneTransitionUuid: z.string().nullable(),
+  currentSceneTransitionKind: z.string().nullable(),
+  transitions: jsonObjectSchema.array()
+});
+const GetCurrentSceneTransitionResponseSchema = z.object({
+  transitionName: z.string(),
+  transitionUuid: z.string(),
+  transitionKind: z.string(),
+  transitionFixed: z.boolean(),
+  transitionDuration: z.number().nullable(),
+  transitionConfigurable: z.boolean(),
+  transitionSettings: jsonObjectSchema.nullable()
+});
+const GetCurrentSceneTransitionCursorResponseSchema = z.object({
+  transitionCursor: z.number()
+});
+class TransitionsModule extends BaseModule {
+  async getTransitionKindList() {
+    const res = await this.obs.call("GetTransitionKindList");
+    return GetTransitionKindListResponseSchema.parse(res);
+  }
+  async getSceneTransitionList() {
+    const res = await this.obs.call("GetSceneTransitionList");
+    return GetSceneTransitionListResponseSchema.parse(res);
+  }
+  async getCurrentSceneTransition() {
+    const res = await this.obs.call("GetCurrentSceneTransition");
+    return GetCurrentSceneTransitionResponseSchema.parse(res);
+  }
+  async setCurrentSceneTransition(params) {
+    SetCurrentSceneTransitionRequestSchema.parse(params);
+    await this.obs.call("SetCurrentSceneTransition", params);
+  }
+  async setCurrentSceneTransitionDuration(params) {
+    SetCurrentSceneTransitionDurationRequestSchema.parse(params);
+    await this.obs.call("SetCurrentSceneTransitionDuration", params);
+  }
+  async setCurrentSceneTransitionSettings(params) {
+    SetCurrentSceneTransitionSettingsRequestSchema.parse(params);
+    await this.obs.call("SetCurrentSceneTransitionSettings", params);
+  }
+  async getCurrentSceneTransitionCursor() {
+    const res = await this.obs.call("GetCurrentSceneTransitionCursor");
+    return GetCurrentSceneTransitionCursorResponseSchema.parse(res);
+  }
+  async triggerStudioModeTransition() {
+    await this.obs.call("TriggerStudioModeTransition");
+  }
+  async setTBarPosition(params) {
+    SetTBarPositionRequestSchema.parse(params);
+    await this.obs.call("SetTBarPosition", params);
+  }
+}
+
+const SetStudioModeEnabledRequestSchema = z.object({
+  studioModeEnabled: z.boolean()
+});
+const OpenInputPropertiesDialogRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const OpenInputFiltersDialogRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const OpenInputInteractDialogRequestSchema = z.object({
+  inputName: z.string().optional(),
+  inputUuid: z.string().optional()
+});
+const OpenVideoMixProjectorRequestSchema = z.object({
+  videoMixType: z.string(),
+  monitorIndex: z.number().optional(),
+  projectorGeometry: z.string().optional()
+});
+const OpenSourceProjectorRequestSchema = z.object({
+  canvasUuid: z.string().optional(),
+  sourceName: z.string().optional(),
+  sourceUuid: z.string().optional(),
+  monitorIndex: z.number().optional(),
+  projectorGeometry: z.string().optional()
+});
+const GetStudioModeEnabledResponseSchema = z.object({
+  studioModeEnabled: z.boolean()
+});
+const GetMonitorListResponseSchema = z.object({
+  monitors: jsonObjectSchema.array()
+});
+class UiModule extends BaseModule {
+  async getStudioModeEnabled() {
+    const res = await this.obs.call("GetStudioModeEnabled");
+    return GetStudioModeEnabledResponseSchema.parse(res);
+  }
+  async setStudioModeEnabled(params) {
+    SetStudioModeEnabledRequestSchema.parse(params);
+    await this.obs.call("SetStudioModeEnabled", params);
+  }
+  async openInputPropertiesDialog(params) {
+    OpenInputPropertiesDialogRequestSchema.parse(params);
+    await this.obs.call("OpenInputPropertiesDialog", params);
+  }
+  async openInputFiltersDialog(params) {
+    OpenInputFiltersDialogRequestSchema.parse(params);
+    await this.obs.call("OpenInputFiltersDialog", params);
+  }
+  async openInputInteractDialog(params) {
+    OpenInputInteractDialogRequestSchema.parse(params);
+    await this.obs.call("OpenInputInteractDialog", params);
+  }
+  async getMonitorList() {
+    const res = await this.obs.call("GetMonitorList");
+    return GetMonitorListResponseSchema.parse(res);
+  }
+  async openVideoMixProjector(params) {
+    OpenVideoMixProjectorRequestSchema.parse(params);
+    await this.obs.call("OpenVideoMixProjector", params);
+  }
+  async openSourceProjector(params) {
+    OpenSourceProjectorRequestSchema.parse(params);
+    await this.obs.call("OpenSourceProjector", params);
+  }
+}
+
+class OBSDK {
+  obs;
+  general;
+  config;
+  sources;
+  scenes;
+  inputs;
+  transitions;
+  filters;
+  sceneItems;
+  outputs;
+  stream;
+  record;
+  mediaInputs;
+  ui;
+  constructor() {
+    this.obs = new OBSWebSocket();
+    this.general = new GeneralModule(this.obs);
+    this.config = new ConfigModule(this.obs);
+    this.sources = new SourcesModule(this.obs);
+    this.scenes = new ScenesModule(this.obs);
+    this.inputs = new InputsModule(this.obs);
+    this.transitions = new TransitionsModule(this.obs);
+    this.filters = new FiltersModule(this.obs);
+    this.sceneItems = new SceneItemsModule(this.obs);
+    this.outputs = new OutputsModule(this.obs);
+    this.stream = new StreamModule(this.obs);
+    this.record = new RecordModule(this.obs);
+    this.mediaInputs = new MediaInputsModule(this.obs);
+    this.ui = new UiModule(this.obs);
+  }
+  async connect(url, password, identificationParams) {
+    await this.obs.connect(url, password, identificationParams);
+  }
+  async disconnect() {
+    await this.obs.disconnect();
+  }
+  callBatch = (...args) => {
+    return this.obs.callBatch(...args);
+  };
+  on = (...args) => {
+    return this.obs.on(...args);
+  };
+  once = (...args) => {
+    return this.obs.once(...args);
+  };
+  off = (...args) => {
+    return this.obs.off(...args);
+  };
+  addListener = (...args) => {
+    return this.obs.addListener(...args);
+  };
+  removeListener = (...args) => {
+    return this.obs.removeListener(...args);
+  };
+  removeAllListeners = (...args) => {
+    return this.obs.removeAllListeners(...args);
+  };
+}
+
+export { ConfigModule, FiltersModule, GeneralModule, InputsModule, MediaInputsModule, OBSDK, OutputsModule, RecordModule, SceneItemsModule, ScenesModule, SourcesModule, StreamModule, TransitionsModule, UiModule };