"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
var _exportNames = {
  TTS: true,
  ASR: true,
  AudioTagging: true,
  SpeakerId: true,
  KWS: true,
  VAD: true,
  LanguageId: true,
  Punctuation: true,
  Diarization: true,
  Denoising: true,
  OnnxInference: true,
  OnnxSession: true,
  LiveSpeakerTurnSession: true,
  LiveAttributedTranscriptionSession: true,
  SegmentedOfflineAsrSession: true,
  typedArrayToBase64: true,
  base64ToTypedArray: true,
  createTensorData: true,
  parseTensorData: true,
  loadWasmModule: true,
  configureSherpaOnnx: true,
  isSherpaOnnxReady: true,
  waitForReady: true
};
exports.LanguageId = exports.KWS = exports.Diarization = exports.Denoising = exports.AudioTagging = exports.ASR = void 0;
Object.defineProperty(exports, "LiveAttributedTranscriptionSession", {
  enumerable: true,
  get: function () {
    return _LiveAttributedTranscriptionSession.LiveAttributedTranscriptionSession;
  }
});
Object.defineProperty(exports, "LiveSpeakerTurnSession", {
  enumerable: true,
  get: function () {
    return _LiveSpeakerTurnSession.LiveSpeakerTurnSession;
  }
});
exports.OnnxInference = void 0;
Object.defineProperty(exports, "OnnxSession", {
  enumerable: true,
  get: function () {
    return _OnnxInferenceService.OnnxSession;
  }
});
exports.Punctuation = void 0;
Object.defineProperty(exports, "SegmentedOfflineAsrSession", {
  enumerable: true,
  get: function () {
    return _SegmentedOfflineAsrSession.SegmentedOfflineAsrSession;
  }
});
exports.VAD = exports.TTS = exports.SpeakerId = void 0;
Object.defineProperty(exports, "base64ToTypedArray", {
  enumerable: true,
  get: function () {
    return _tensorUtils.base64ToTypedArray;
  }
});
Object.defineProperty(exports, "configureSherpaOnnx", {
  enumerable: true,
  get: function () {
    return _wasmLoader.configureSherpaOnnx;
  }
});
Object.defineProperty(exports, "createTensorData", {
  enumerable: true,
  get: function () {
    return _tensorUtils.createTensorData;
  }
});
exports.default = void 0;
Object.defineProperty(exports, "isSherpaOnnxReady", {
  enumerable: true,
  get: function () {
    return _wasmLoader.isSherpaOnnxReady;
  }
});
Object.defineProperty(exports, "loadWasmModule", {
  enumerable: true,
  get: function () {
    return _wasmLoader.loadWasmModule;
  }
});
Object.defineProperty(exports, "parseTensorData", {
  enumerable: true,
  get: function () {
    return _tensorUtils.parseTensorData;
  }
});
Object.defineProperty(exports, "typedArrayToBase64", {
  enumerable: true,
  get: function () {
    return _tensorUtils.typedArrayToBase64;
  }
});
Object.defineProperty(exports, "waitForReady", {
  enumerable: true,
  get: function () {
    return _wasmLoader.waitForReady;
  }
});
var _SherpaOnnxAPI = require("./SherpaOnnxAPI.js");
var _ArchiveService = require("./services/ArchiveService.js");
var _AsrService = require("./services/AsrService.js");
var _AudioTaggingService = require("./services/AudioTaggingService.js");
var _DiarizationService = require("./services/DiarizationService.js");
var _DenoisingService = require("./services/DenoisingService.js");
var _KWSService = require("./services/KWSService.js");
var _LanguageIdService = require("./services/LanguageIdService.js");
var _PunctuationService = require("./services/PunctuationService.js");
var _SpeakerIdService = require("./services/SpeakerIdService.js");
var _TtsService = require("./services/TtsService.js");
var _OnnxInferenceService = require("./services/OnnxInferenceService.js");
var _VadService = require("./services/VadService.js");
var _LiveSpeakerTurnSession = require("./services/LiveSpeakerTurnSession.js");
var _LiveAttributedTranscriptionSession = require("./services/LiveAttributedTranscriptionSession.js");
var _SegmentedOfflineAsrSession = require("./services/SegmentedOfflineAsrSession.js");
var _api = require("./types/api.js");
Object.keys(_api).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _api[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _api[key];
    }
  });
});
var _interfaces = require("./types/interfaces.js");
Object.keys(_interfaces).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _interfaces[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _interfaces[key];
    }
  });
});
var _tensorUtils = require("./utils/tensorUtils.js");
var _wasmLoader = require("./web/wasmLoader.js");
// Initialize services with API
const api = _SherpaOnnxAPI.SherpaOnnxAPI;
const ttsService = new _TtsService.TtsService(api);
const asrService = new _AsrService.AsrService(api);
const audioTaggingService = new _AudioTaggingService.AudioTaggingService(api);
const speakerIdService = new _SpeakerIdService.SpeakerIdService(api);
const kwsService = new _KWSService.KWSService(api);
const vadService = new _VadService.VadService(api);
const languageIdService = new _LanguageIdService.LanguageIdService(api);
const punctuationService = new _PunctuationService.PunctuationService(api);
const archiveService = new _ArchiveService.ArchiveService(api);
const diarizationService = new _DiarizationService.DiarizationService(api);
const denoisingService = new _DenoisingService.DenoisingService(api);
const onnxInferenceService = new _OnnxInferenceService.OnnxInferenceService(api);

// Create the public interface
const SherpaOnnx = {
  ...api,
  TTS: ttsService,
  ASR: asrService,
  AudioTagging: audioTaggingService,
  SpeakerId: speakerIdService,
  KWS: kwsService,
  VAD: vadService,
  LanguageId: languageIdService,
  Punctuation: punctuationService,
  Archive: archiveService,
  Diarization: diarizationService,
  Denoising: denoisingService,
  OnnxInference: onnxInferenceService,
  LiveSpeakerTurnSession: _LiveSpeakerTurnSession.LiveSpeakerTurnSession,
  LiveAttributedTranscriptionSession: _LiveAttributedTranscriptionSession.LiveAttributedTranscriptionSession,
  SegmentedOfflineAsrSession: _SegmentedOfflineAsrSession.SegmentedOfflineAsrSession
};

// Export the main interface
var _default = exports.default = SherpaOnnx; // Export services for direct use
const TTS = exports.TTS = ttsService;
const ASR = exports.ASR = asrService;
const AudioTagging = exports.AudioTagging = audioTaggingService;
const SpeakerId = exports.SpeakerId = speakerIdService;
const KWS = exports.KWS = kwsService;
const VAD = exports.VAD = vadService;
const LanguageId = exports.LanguageId = languageIdService;
const Punctuation = exports.Punctuation = punctuationService;
const Diarization = exports.Diarization = diarizationService;
const Denoising = exports.Denoising = denoisingService;
const OnnxInference = exports.OnnxInference = onnxInferenceService;

// Export types

// Export tensor utilities

// Export OnnxSession class

// Export web utilities
//# sourceMappingURL=index.js.map