yomitan-core 1.5.0 → 1.7.0

package/dist/anki-note-service-BEzTEDPY.d.ts

@@ -0,0 +1,860 @@
+import { DictionaryEntry, DictionaryEntryType, InflectionRuleChainCandidate, KanjiDictionaryEntry, Tag$1 as Tag, TermDictionaryEntry, TermGlossaryContent } from "./dictionary-o42ErAc-.js";
+import { Summary } from "./dictionary-importer-BUhx1hez.js";
+
+//#region src/types/anki.d.ts
+type NoteId = number;
+type CardId = number;
+type NoteWithId = Note & {
+  id: NoteId;
+};
+type Note = {
+  fields: NoteFields;
+  tags: string[];
+  deckName: string;
+  modelName: string;
+  options: {
+    allowDuplicate: boolean;
+    duplicateScope: string;
+    duplicateScopeOptions: {
+      deckName: string | null;
+      checkChildren: boolean;
+      checkAllModels: boolean;
+    };
+  };
+};
+type NoteFields = {
+  [field: string]: string;
+};
+type NoteInfoWrapper = {
+  canAdd: boolean;
+  valid: boolean;
+  noteIds: NoteId[] | null;
+  noteInfos?: (NoteInfo | null)[];
+};
+type NoteInfo = {
+  noteId: NoteId;
+  tags: string[];
+  fields: {
+    [key: string]: NoteFieldInfo;
+  };
+  modelName: string;
+  cards: CardId[];
+  cardsInfo: CardInfo[];
+};
+type NoteFieldInfo = {
+  value: string;
+  order: number;
+};
+type CardInfo = {
+  noteId: NoteId;
+  cardId: CardId;
+  flags: number;
+  cardState: number;
+};
+type ApiReflectResult = {
+  scopes: string[];
+  actions: string[];
+};
+type MessageBody = {
+  action: string;
+  params: {
+    [key: string]: unknown;
+  };
+  version: number;
+  key?: string;
+};
+type CanAddNotesDetail = {
+  canAdd: boolean;
+  error: string | null;
+}; //#endregion
+//#region src/anki/anki-note-builder.d.ts
+
+//# sourceMappingURL=anki.d.ts.map
+/**
+ * Represents a template rendering result.
+ */
+type RenderResult$1 = {
+  result: string;
+  requirements: Requirement[];
+};
+/**
+ * Represents a rendering response from renderMulti.
+ */
+type RenderMultiResponse$1 = {
+  result?: RenderResult$1;
+  error?: SerializedError;
+};
+type SerializedError = {
+  name?: string;
+  message?: string;
+  stack?: string;
+  data?: unknown;
+};
+/**
+ * Interface for a template renderer that can be injected into AnkiNoteBuilder.
+ */
+interface TemplateRenderer {
+  getModifiedData(data: {
+    marker: string;
+    commonData: CommonData;
+  }, type: string): Promise<NoteData$1>;
+  renderMulti(items: RenderMultiItem$1[]): Promise<RenderMultiResponse$1[]>;
+}
+type RenderMultiItem$1 = {
+  template: string;
+  templateItems: RenderMultiTemplateItem$1[];
+};
+type RenderMultiTemplateItem$1 = {
+  type: string;
+  commonData: CommonData;
+  datas: PartialRenderData$1[];
+};
+type PartialRenderData$1 = {
+  marker: string;
+};
+/**
+ * Common data passed through the template rendering process.
+ */
+type CommonData = {
+  dictionaryEntry: DictionaryEntry;
+  cardFormat: AnkiCardFormat;
+  context: Context;
+  resultOutputMode: ResultOutputMode;
+  glossaryLayoutMode: GlossaryLayoutMode;
+  compactTags: boolean;
+  media?: Media;
+  dictionaryStylesMap: Map<string, string>;
+};
+type AnkiCardFormat = {
+  deck: string;
+  model: string;
+  fields: {
+    [fieldName: string]: {
+      value: string;
+    };
+  };
+};
+type Context = {
+  url: string;
+  sentence?: {
+    text: string;
+    offset: number;
+  };
+  query: string;
+  fullQuery: string;
+  documentTitle?: string;
+};
+type ResultOutputMode = 'group' | 'merge' | 'split';
+type GlossaryLayoutMode = 'default' | 'compact' | 'compact-popup-anki';
+type MediaObject = {
+  value: string;
+};
+type Media = {
+  audio?: MediaObject;
+  screenshot?: MediaObject;
+  clipboardImage?: MediaObject;
+  clipboardText?: MediaObject;
+  popupSelectionText?: MediaObject;
+  textFurigana: TextFuriganaSegment[];
+  dictionaryMedia: DictionaryMedia;
+};
+type TextFuriganaSegment = {
+  text: string;
+  readingMode: TextFuriganaReadingMode | null;
+  detailsHtml: MediaObject;
+  detailsPlain: MediaObject;
+};
+type TextFuriganaReadingMode = 'hiragana' | 'katakana';
+type DictionaryMedia = {
+  [dictionary: string]: {
+    [path: string]: MediaObject;
+  };
+};
+type NoteData$1 = Record<string, unknown>;
+type Requirement = {
+  type: 'audio';
+} | {
+  type: 'screenshot';
+} | {
+  type: 'clipboardImage';
+} | {
+  type: 'clipboardText';
+} | {
+  type: 'popupSelectionText';
+} | {
+  type: 'textFurigana';
+  text: string;
+  readingMode: TextFuriganaReadingMode | null;
+} | {
+  type: 'dictionaryMedia';
+  dictionary: string;
+  path: string;
+};
+type CreateNoteDetails = {
+  dictionaryEntry: DictionaryEntry;
+  cardFormat: AnkiCardFormat;
+  context: Context;
+  template: string;
+  tags?: string[];
+  requirements?: Requirement[];
+  duplicateScope?: string;
+  duplicateScopeCheckAllModels?: boolean;
+  resultOutputMode?: ResultOutputMode;
+  glossaryLayoutMode?: GlossaryLayoutMode;
+  compactTags?: boolean;
+  mediaOptions?: MediaOptions | null;
+  dictionaryStylesMap?: Map<string, string>;
+};
+type MediaOptions = {
+  audio?: {
+    sources: {
+      type: string;
+      url: string;
+      voice: string;
+    }[];
+    preferredAudioIndex: number | null;
+    idleTimeout: number | null;
+    languageSummary: unknown;
+    enableDefaultAudioSources: boolean;
+  };
+  screenshot?: {
+    format: string;
+    quality: number;
+    contentOrigin: {
+      tabId: number;
+      frameId: number;
+    };
+  };
+  textParsing?: {
+    optionsContext: unknown;
+    scanLength: number;
+  };
+};
+type CreateNoteResult = {
+  note: Note;
+  errors: Error[];
+  requirements: Requirement[];
+};
+type InjectAnkiNoteMediaDefinitionDetails = {
+  type: 'kanji';
+  character: string;
+} | {
+  type: 'term';
+  term: string;
+  reading: string;
+};
+/**
+ * Minimal API interface needed by AnkiNoteBuilder for media injection.
+ */
+interface MinimalApi {
+  injectAnkiNoteMedia(timestamp: number, dictionaryEntryDetails: InjectAnkiNoteMediaDefinitionDetails, audioDetails: unknown, screenshotDetails: unknown, clipboardDetails: {
+    image: boolean;
+    text: boolean;
+  }, dictionaryMediaDetails: {
+    dictionary: string;
+    path: string;
+  }[]): Promise<{
+    audioFileName: string | null;
+    screenshotFileName: string | null;
+    clipboardImageFileName: string | null;
+    clipboardText: string | null;
+    dictionaryMedia: {
+      dictionary: string;
+      path: string;
+      fileName: string | null;
+    }[];
+    errors: SerializedError[];
+  }>;
+  parseText(text: string, optionsContext: unknown, scanLength: number, useInternalParser: boolean, useMecabParser: boolean): Promise<{
+    source: string;
+    content: unknown;
+  }[]>;
+}
+/**
+ * Builds Anki notes from dictionary entries using template rendering.
+ */
+declare class AnkiNoteBuilder {
+  private _api;
+  private _markerPattern;
+  private _templateRenderer;
+  private _batchedRequests;
+  private _batchedRequestsQueued;
+  constructor(templateRenderer: TemplateRenderer, api?: MinimalApi);
+  createNote({
+    dictionaryEntry,
+    cardFormat,
+    context,
+    template,
+    tags,
+    requirements,
+    duplicateScope,
+    duplicateScopeCheckAllModels,
+    resultOutputMode,
+    glossaryLayoutMode,
+    compactTags,
+    mediaOptions,
+    dictionaryStylesMap
+  }: CreateNoteDetails): Promise<CreateNoteResult>;
+  getRenderingData({
+    dictionaryEntry,
+    cardFormat,
+    context,
+    resultOutputMode,
+    glossaryLayoutMode,
+    compactTags,
+    marker,
+    dictionaryStylesMap
+  }: {
+    dictionaryEntry: DictionaryEntry;
+    cardFormat: AnkiCardFormat;
+    context: Context;
+    resultOutputMode?: ResultOutputMode;
+    glossaryLayoutMode?: GlossaryLayoutMode;
+    compactTags?: boolean;
+    marker: string;
+    dictionaryStylesMap: Map<string, string>;
+  }): Promise<NoteData$1>;
+  getDictionaryEntryDetailsForNote(dictionaryEntry: DictionaryEntry): InjectAnkiNoteMediaDefinitionDetails;
+  private _createData;
+  private _formatField;
+  private _stringReplaceAsync;
+  private _getBatchedTemplateGroup;
+  private _renderTemplateBatched;
+  private _runBatchedRequestsDelayed;
+  private _runBatchedRequests;
+  private _resolveBatchedRequests;
+  private _injectMedia;
+  private _deserializeError;
+} //#endregion
+//#region src/anki/anki-note-data-creator.d.ts
+
+//# sourceMappingURL=anki-note-builder.d.ts.map
+type NoteData = {
+  marker: string;
+  definition: AnkiDictionaryEntry;
+  glossaryLayoutMode: GlossaryLayoutMode;
+  compactTags: boolean;
+  group: boolean;
+  merge: boolean;
+  compactGlossaries: boolean;
+  uniqueExpressions: string[];
+  uniqueReadings: string[];
+  pitches: PitchGroup[];
+  pitchCount: number;
+  phoneticTranscriptions: TranscriptionGroup[];
+  context: PublicContext;
+  media: Media;
+  dictionaryEntry: DictionaryEntry;
+};
+type PublicContext = {
+  query: string;
+  fullQuery: string;
+  document: {
+    title: string;
+  };
+};
+type AnkiDictionaryEntry = AnkiTermDictionaryEntry | AnkiKanjiDictionaryEntry | Record<string, never>;
+type TermDictionaryEntryType = 'term' | 'termGrouped' | 'termMerged';
+type Tag$1 = {
+  name: string;
+  category: string;
+  notes: string;
+  order: number;
+  score: number;
+  dictionary: string;
+  redundant: boolean;
+};
+type PitchTag = {
+  name: string;
+  category: string;
+  order: number;
+  score: number;
+  content: string[];
+  dictionaries: string[];
+  redundant: boolean;
+};
+type Pitch = {
+  expressions: string[];
+  reading: string;
+  positions: number | string;
+  nasalPositions: number[];
+  devoicePositions: number[];
+  tags: PitchTag[];
+  exclusiveExpressions: string[];
+  exclusiveReadings: string[];
+};
+type PitchGroup = {
+  dictionary: string;
+  pitches: Pitch[];
+};
+type Transcription = {
+  expressions: string[];
+  reading: string;
+  ipa: string;
+  tags: Tag[];
+  exclusiveExpressions: string[];
+  exclusiveReadings: string[];
+};
+type TranscriptionGroup = {
+  dictionary: string;
+  phoneticTranscriptions: Transcription[];
+};
+type FuriganaSegment = {
+  text: string;
+  furigana: string;
+};
+type Cloze = {
+  sentence: string;
+  prefix: string;
+  body: string;
+  bodyKana: string;
+  suffix: string;
+};
+type FrequencyNumber = {
+  dictionary: string;
+  frequency: number;
+};
+type TermFrequencyEntry = {
+  index: number;
+  expressionIndex: number;
+  dictionary: string;
+  dictionaryAlias: string;
+  dictionaryOrder: {
+    index: number;
+  };
+  expression: string;
+  reading: string;
+  hasReading: boolean;
+  frequency: number | string;
+};
+type TermPitchAccent = {
+  index: number;
+  expressionIndex: number;
+  dictionary: string;
+  dictionaryAlias: string;
+  dictionaryOrder: {
+    index: number;
+  };
+  expression: string;
+  reading: string;
+  pitches: {
+    positions: number | string;
+    tags: Tag$1[];
+  }[];
+};
+type TermPhoneticTranscription = {
+  index: number;
+  expressionIndex: number;
+  dictionary: string;
+  dictionaryAlias: string;
+  dictionaryOrder: {
+    index: number;
+  };
+  expression: string;
+  reading: string;
+  phoneticTranscriptions: {
+    ipa: string;
+    tags: Tag$1[];
+  }[];
+};
+type TermHeadword = {
+  sourceTerm: string;
+  expression: string;
+  reading: string;
+  termTags: Tag$1[];
+  frequencies: TermFrequencyEntry[];
+  pitches: TermPitchAccent[];
+  furiganaSegments: FuriganaSegment[];
+  termFrequency: 'popular' | 'rare' | 'normal';
+  wordClasses: string[];
+};
+type TermDefinition = {
+  sequence: number;
+  dictionary: string;
+  dictionaryAlias: string;
+  glossaryScopedStyles: string;
+  dictScopedStyles: string;
+  glossary: TermGlossaryContent[];
+  definitionTags: Tag$1[];
+  only?: string[];
+};
+type KanjiStat = {
+  name: string;
+  category: string;
+  notes: string;
+  order: number;
+  score: number;
+  dictionary: string;
+  value: number | string;
+};
+type KanjiStatGroups = {
+  [key: string]: KanjiStat[];
+};
+type KanjiFrequencyEntry = {
+  index: number;
+  dictionary: string;
+  dictionaryAlias: string;
+  dictionaryOrder: {
+    index: number;
+  };
+  character: string;
+  frequency: number | string;
+};
+type AnkiTermDictionaryEntry = {
+  type: TermDictionaryEntryType;
+  id?: number;
+  source: string | null;
+  rawSource: string | null;
+  sourceTerm?: string | null;
+  inflectionRuleChainCandidates: InflectionRuleChainCandidate[];
+  score: number;
+  isPrimary?: boolean;
+  sequence: number;
+  dictionary: string;
+  dictionaryAlias: string;
+  dictionaryOrder: {
+    index: number;
+  };
+  dictionaryNames: string[];
+  expression: string | string[];
+  reading: string | string[];
+  expressions: TermHeadword[];
+  glossary?: TermGlossaryContent[];
+  glossaryScopedStyles?: string;
+  dictScopedStyles?: string;
+  definitionTags?: Tag$1[];
+  termTags?: Tag$1[];
+  definitions?: TermDefinition[];
+  frequencies: TermFrequencyEntry[];
+  frequencyNumbers: FrequencyNumber[];
+  frequencyHarmonic: number;
+  frequencyAverage: number;
+  pitches: TermPitchAccent[];
+  phoneticTranscriptions: TermPhoneticTranscription[];
+  sourceTermExactMatchCount: number;
+  url: string;
+  cloze: Cloze;
+  furiganaSegments?: FuriganaSegment[];
+};
+type AnkiKanjiDictionaryEntry = {
+  type: 'kanji';
+  character: string;
+  dictionary: string;
+  dictionaryAlias: string;
+  onyomi: string[];
+  kunyomi: string[];
+  glossary: string[];
+  tags: Tag$1[];
+  stats: KanjiStatGroups;
+  frequencies: KanjiFrequencyEntry[];
+  frequencyHarmonic: number;
+  frequencyAverage: number;
+  url: string;
+  cloze: Cloze;
+};
+type CachedValue<T> = {
+  getter: () => T;
+  hasValue: boolean;
+  value: T | undefined;
+};
+declare function createCachedValue<T>(getter: () => T): CachedValue<T>;
+declare function getCachedValue<T>(item: CachedValue<T>): T;
+/**
+ * Creates a compatibility representation of the specified data for Anki template rendering.
+ */
+declare function createAnkiNoteData(marker: string, details: CommonData): NoteData;
+declare function getFrequencyHarmonic(dictionaryEntry: TermDictionaryEntry | KanjiDictionaryEntry, headwordIndex: number | null): number;
+
+//#endregion
+//#region src/types/core.d.ts
+type TypeofResult = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function';
+type SafeAny = any;
+type RejectionReason = SafeAny;
+type SerializableObject = {
+  [key: string]: unknown;
+};
+type UnknownObject = {
+  [key: string | symbol]: unknown;
+};
+type TokenString = string;
+type TokenObject = Record<string, never>;
+type DeferredPromiseDetails<T = unknown> = {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (reason?: RejectionReason) => void;
+};
+type EventSurface = {
+  [name: string]: unknown;
+};
+type EventNames<TSurface extends EventSurface> = keyof TSurface & string;
+type EventArgument<TSurface extends EventSurface, TName extends EventNames<TSurface>> = TSurface[TName];
+type EventHandler<TSurface extends EventSurface, TName extends EventNames<TSurface>> = (details: EventArgument<TSurface, TName>) => void;
+type EventHandlerAny = (details: SafeAny) => void;
+type EventDispatcherOffGeneric = {
+  off(eventName: string, callback: (...args: SafeAny) => void): boolean;
+};
+type Timeout = number | ReturnType<typeof setTimeout>;
+
+//#endregion
+//#region src/anki/anki-template-renderer.d.ts
+//# sourceMappingURL=core.d.ts.map
+type HelperOptions = {
+  fn?: (context: unknown) => string;
+  inverse?: (context: unknown) => string;
+  hash: SerializableObject;
+  data: {
+    root: NoteData;
+  };
+};
+type HelperFunction<T = unknown> = (args: unknown[], context: unknown, options: HelperOptions) => T;
+type DataType = {
+  modifier: (data: CompositeRenderData) => NoteData;
+  composeData: (data: PartialRenderData, commonData: CommonData) => CompositeRenderData;
+};
+type PartialRenderData = {
+  marker: string;
+  commonData?: CommonData;
+};
+type CompositeRenderData = {
+  marker: string;
+  commonData: CommonData;
+};
+type RenderResult = {
+  result: string;
+  requirements: Requirement[];
+};
+type RenderMultiItem = {
+  template: string;
+  templateItems: RenderMultiTemplateItem[];
+};
+type RenderMultiTemplateItem = {
+  type: string;
+  commonData: CommonData;
+  datas: PartialRenderData[];
+};
+type RenderMultiResponse = {
+  result?: RenderResult;
+  error?: {
+    name?: string;
+    message?: string;
+    stack?: string;
+    data?: unknown;
+  };
+};
+/**
+ * Interface for a Handlebars-compatible template engine.
+ * Consumers should provide an implementation that wraps their Handlebars instance.
+ */
+interface HandlebarsInstance {
+  compileAST(template: string): (data: NoteData) => string;
+  registerHelper(name: string, helper: (...args: unknown[]) => unknown): void;
+  SafeString: new (value: string) => unknown;
+  Utils: {
+    escapeExpression(value: string): string;
+  };
+}
+declare class TemplateRendererCore {
+  private _cache;
+  private _cacheMaxSize;
+  private _dataTypes;
+  private _renderSetup;
+  private _renderCleanup;
+  private _handlebars;
+  constructor(handlebars: HandlebarsInstance);
+  registerHelpers(helpers: [string, HelperFunction][]): void;
+  registerDataType(name: string, details: DataType): void;
+  setRenderCallbacks(setup: ((data: NoteData) => {
+    requirements: Requirement[];
+  }) | null, cleanup: ((data: NoteData) => void) | null): void;
+  render(template: string, data: PartialRenderData, type: string): RenderResult;
+  renderMulti(items: RenderMultiItem[]): RenderMultiResponse[];
+  getModifiedData(data: CompositeRenderData, type: string): NoteData;
+  private _getTemplateInstance;
+  private _renderTemplate;
+  private _getModifiedData;
+  private _updateCacheSize;
+  private _registerHelper;
+}
+/**
+ * This class contains all Anki-specific template rendering functionality.
+ * It registers all 25+ Handlebars helpers and provides template rendering.
+ *
+ * Requires a Handlebars-compatible engine to be injected via the constructor.
+ */
+declare class AnkiTemplateRenderer {
+  private _templateRenderer;
+  private _mediaProvider;
+  private _stateStack;
+  private _requirements;
+  private _cleanupCallbacks;
+  private _document;
+  private _handlebars;
+  constructor(handlebars: HandlebarsInstance);
+  /**
+   * Gets the core TemplateRenderer instance.
+   */
+  get templateRenderer(): TemplateRendererCore;
+  /**
+   * Prepares the renderer by registering all Handlebars helpers and data types.
+   */
+  prepare(): Promise<void>;
+  /**
+   * Renders a single template with given data.
+   */
+  render(template: string, data: PartialRenderData, type: string): RenderResult;
+  /**
+   * Renders multiple templates with given data.
+   */
+  renderMulti(items: RenderMultiItem[]): RenderMultiResponse[];
+  /**
+   * Gets modified data for a given type.
+   */
+  getModifiedData(data: CompositeRenderData, type: string): NoteData;
+  private _onRenderSetup;
+  private _onRenderCleanup;
+  private _safeString;
+  private _dumpObject;
+  private _furigana;
+  private _furiganaPlain;
+  private _getFuriganaExpressionAndReading;
+  private _stringToMultiLineHtml;
+  private _multiLine;
+  private _regexReplace;
+  private _regexMatch;
+  private _mergeTags;
+  private _eachUpTo;
+  private _spread;
+  private _op;
+  private _evaluateUnaryExpression;
+  private _evaluateBinaryExpression;
+  private _evaluateTernaryExpression;
+  private _get;
+  private _set;
+  private _scope;
+  private _property;
+  private _noop;
+  private _isMoraPitchHigh;
+  private _getKanaMorae;
+  private _getTypeof;
+  private _join;
+  private _concat;
+  private _pitchCategories;
+  private _formatGlossary;
+  private _formatGlossaryPlain;
+  private _formatStructuredContent;
+  private _createStructuredContentNode;
+  private _getNodeHtml;
+  private _extractStructuredContentText;
+  private _extractStructuredContentTextParts;
+  private _hasMedia;
+  private _getMedia;
+  private _hiragana;
+  private _katakana;
+  private _getNoteDataFromOptions;
+  private _asString;
+  private _computeValue;
+  private _computeValueString;
+  private _computeInverse;
+  private _computeInverseString;
+}
+
+//#endregion
+//#region src/types/settings.d.ts
+type AnkiDuplicateScope = 'collection' | 'deck' | 'deck-root';
+type ProfileOptions = {
+  general: GeneralOptions;
+  audio: AudioOptions;
+  anki: AnkiOptions;
+  translation: TranslationOptions;
+};
+type GeneralOptions = {
+  language: string;
+  resultOutputMode: 'group' | 'merge' | 'split';
+  mainDictionary: string;
+  sortFrequencyDictionary: string | null;
+  sortFrequencyDictionaryOrder: 'ascending' | 'descending';
+};
+type AudioOptions = {
+  enabled: boolean;
+  sources: AudioSourceOptions[];
+  volume: number;
+};
+type AudioSourceOptions = {
+  type: string;
+  url: string;
+  voice: string;
+};
+type AnkiOptions = {
+  enable: boolean;
+  server: string;
+  apiKey: string;
+  duplicateScope: AnkiDuplicateScope;
+};
+type TranslationOptions = {
+  searchResolution: 'letter' | 'word';
+  textReplacements: {
+    searchOriginal: string;
+    searchReplacement: string;
+  }[];
+};
+
+//#endregion
+//#region src/anki/anki-template-util.d.ts
+//# sourceMappingURL=settings.d.ts.map
+type DictionaryMarkerSource = {
+  name: string;
+  enabled: boolean;
+};
+/**
+ * Gets the standard marker names available for a given entry type.
+ */
+declare function getStandardFieldMarkers(type: DictionaryEntryType, language?: string): string[];
+/**
+ * Returns dynamic marker names derived from enabled dictionaries.
+ */
+declare function getDynamicFieldMarkers(dictionaries: DictionaryMarkerSource[], dictionaryInfo: Summary[]): string[];
+/**
+ * Returns dynamic inline template partials derived from enabled dictionaries.
+ */
+declare function getDynamicTemplates(dictionaries: DictionaryMarkerSource[], dictionaryInfo: Summary[]): string;
+declare function getKebabCase(str: string): string;
+
+//#endregion
+//#region src/anki/anki-note-service.d.ts
+//# sourceMappingURL=anki-template-util.d.ts.map
+type BuildAnkiNoteFromDictionaryEntryInput = {
+  dictionaryEntry: DictionaryEntry;
+  cardFormat: AnkiCardFormat;
+  context: Context;
+  tags?: string[];
+  template?: string;
+  duplicateScope?: AnkiDuplicateScope;
+  duplicateScopeCheckAllModels?: boolean;
+  resultOutputMode?: ResultOutputMode;
+  glossaryLayoutMode?: GlossaryLayoutMode;
+  compactTags?: boolean;
+  dictionaryStylesMap?: Map<string, string>;
+};
+type BuildAnkiNoteFromTermResult = {
+  status: 'ok';
+  fields: Record<string, string>;
+  errors: string[];
+} | {
+  status: 'no-entry';
+  errors: string[];
+};
+declare function createDefaultAnkiTemplateRenderer(handlebars?: HandlebarsInstance): Promise<AnkiTemplateRenderer>;
+declare function getDefaultAnkiFieldTemplates(dynamicTemplates?: string): string;
+declare function buildAnkiNoteFromDictionaryEntry(input: BuildAnkiNoteFromDictionaryEntryInput, handlebars?: HandlebarsInstance): Promise<CreateNoteResult>;
+declare function buildAnkiNoteFromTerm(input: Omit<BuildAnkiNoteFromDictionaryEntryInput, 'dictionaryEntry' | 'template'> & {
+  entries: DictionaryEntry[];
+  dictionaries?: DictionaryMarkerSource[];
+  dictionaryInfo?: Summary[];
+  template?: string;
+}, handlebars?: HandlebarsInstance): Promise<BuildAnkiNoteFromTermResult>;
+
+//#endregion
+//# sourceMappingURL=anki-note-service.d.ts.map
+
+export { AnkiCardFormat, AnkiDictionaryEntry, AnkiDuplicateScope, AnkiKanjiDictionaryEntry, AnkiNoteBuilder as AnkiNoteBuilder$1, AnkiOptions, AnkiTemplateRenderer as AnkiTemplateRenderer$1, AnkiTermDictionaryEntry, ApiReflectResult, AudioOptions, AudioSourceOptions, BuildAnkiNoteFromDictionaryEntryInput, BuildAnkiNoteFromTermResult, CanAddNotesDetail, CardId, CardInfo, Cloze, CommonData, CompositeRenderData, Context, CreateNoteDetails, CreateNoteResult, DataType, DeferredPromiseDetails, DictionaryMarkerSource, DictionaryMedia, EventArgument, EventDispatcherOffGeneric, EventHandler, EventHandlerAny, EventNames, EventSurface, FrequencyNumber, FuriganaSegment, GeneralOptions, GlossaryLayoutMode, HandlebarsInstance, HelperFunction, HelperOptions, InjectAnkiNoteMediaDefinitionDetails, KanjiFrequencyEntry, KanjiStat, KanjiStatGroups, Media, MediaObject, MediaOptions, MessageBody, MinimalApi, Note, NoteData, NoteData$1, NoteFieldInfo, NoteFields, NoteId, NoteInfo, NoteInfoWrapper, NoteWithId, PartialRenderData, Pitch, PitchGroup, PitchTag, ProfileOptions, PublicContext, RejectionReason, RenderMultiItem, RenderMultiItem$1, RenderMultiResponse, RenderMultiResponse$1, RenderResult, RenderResult$1, Requirement, ResultOutputMode, SafeAny, SerializableObject, SerializedError, Tag$1 as Tag, TemplateRenderer, TermDefinition, TermDictionaryEntryType, TermFrequencyEntry, TermHeadword, TermPhoneticTranscription, TermPitchAccent, TextFuriganaReadingMode, TextFuriganaSegment, Timeout, TokenObject, TokenString, Transcription, TranscriptionGroup, TranslationOptions, TypeofResult, UnknownObject, buildAnkiNoteFromDictionaryEntry as buildAnkiNoteFromDictionaryEntry$1, buildAnkiNoteFromTerm as buildAnkiNoteFromTerm$1, createAnkiNoteData as createAnkiNoteData$1, createCachedValue as createCachedValue$1, createDefaultAnkiTemplateRenderer as createDefaultAnkiTemplateRenderer$1, getCachedValue as getCachedValue$1, getDefaultAnkiFieldTemplates as getDefaultAnkiFieldTemplates$1, getDynamicFieldMarkers as getDynamicFieldMarkers$1, getDynamicTemplates as getDynamicTemplates$1, getFrequencyHarmonic as getFrequencyHarmonic$1, getKebabCase as getKebabCase$1, getStandardFieldMarkers as getStandardFieldMarkers$1 };
+//# sourceMappingURL=anki-note-service-BEzTEDPY.d.ts.map