yanki 0.2.0

package/dist/lib/index.d.ts

@@ -0,0 +1,1022 @@
+type CardBrowserColumns = 'answer' | 'cardDue' | 'cardEase' | 'cardIvl' | 'cardLapses' | 'cardMod' | 'cardReps' | 'deck' | 'note' | 'noteCrt' | 'noteFld' | 'noteMod' | 'noteTags' | 'question' | 'template' | ({} & string);
+type CardValueKeys = 'data' | 'did' | 'due' | 'factor' | 'flags' | 'id' | 'ivl' | 'lapses' | 'left' | 'mod' | 'odid' | 'odue' | 'ord' | 'queue' | 'reps' | 'type' | 'usn';
+type CardInfo = {
+    answer: string;
+    buttons?: number[];
+    cardId: number;
+    css: string;
+    deckName: string;
+    due: number;
+    fieldOrder: number;
+    fields: Record<string, {
+        order: number;
+        value: string;
+    }>;
+    interval: number;
+    lapses: number;
+    left: number;
+    mod: number;
+    modelName: string;
+    nextReviews: string[];
+    note: number;
+    ord: number;
+    question: string;
+    queue: number;
+    reps: number;
+    template: string;
+    type: number;
+};
+type CardRequests = Request<'cardsModTime', 6, {
+    cards: number[];
+}, {
+    cardId: number;
+    mod: number;
+}> | Request<'setSpecificValueOfCard', 6, {
+    card: number;
+    keys: CardValueKeys[];
+    newValues: string[];
+}, boolean[]> | Request<'answerCards', 6, {
+    answers: Array<{
+        cardId: number;
+        ease: number;
+    }>;
+}, boolean[]> | Request<'areDue', 6, {
+    cards: number[];
+}, boolean[]> | Request<'areSuspended', 6, {
+    cards: number[];
+}, Array<boolean | null>> | Request<'cardsInfo', 6, {
+    cards: number[];
+}, CardInfo[]> | Request<'cardsToNotes', 6, {
+    cards: number[];
+}, number[]> | Request<'findCards', 6, {
+    query: string;
+}, number[]> | Request<'forgetCards', 6, {
+    cards: number[];
+}> | Request<'getEaseFactors', 6, {
+    cards: number[];
+}, number[]> | Request<'getIntervals', 6, {
+    cards: number[];
+    complete?: boolean;
+}, number[] | number[][]> | Request<'relearnCards', 6, {
+    cards: number[];
+}> | Request<'setEaseFactors', 6, {
+    cards: number[];
+    easeFactors: number[];
+}, boolean[]> | Request<'suspend', 6, {
+    cards: number[];
+}, boolean> | Request<'suspended', 6, {
+    card: number;
+}, boolean> | Request<'unsuspend', 6, {
+    cards: number[];
+}, boolean>;
+
+type DeckStats = {
+    deck_id: number;
+    learn_count: number;
+    name: string;
+    new_count: number;
+    review_count: number;
+    total_in_deck: number;
+};
+type DeckConfig = {
+    autoplay: boolean;
+    dyn: boolean;
+    id: number;
+    lapse: {
+        delays: number[];
+        leechAction: number;
+        leechFails: number;
+        minInt: number;
+        mult: number;
+    };
+    maxTaken: number;
+    mod: number;
+    name: string;
+    new: {
+        bury: boolean;
+        delays: number[];
+        initialFactor: number;
+        ints: number[];
+        order: number;
+        perDay: number;
+        separate: boolean;
+    };
+    replayq: boolean;
+    rev: {
+        bury: boolean;
+        ease4: number;
+        fuzz: number;
+        ivlFct: number;
+        maxIvl: number;
+        minSpace: number;
+        perDay: number;
+    };
+    timer: number;
+    usn: number;
+};
+type DeckRequests = Request<'changeDeck', 6, {
+    cards: number[];
+    deck: string;
+}> | Request<'cloneDeckConfigId', 6, {
+    cloneFrom: number;
+    name: string;
+}, false | number> | Request<'createDeck', 6, {
+    deck: string;
+}, Record<string, number>> | Request<'deckNames', 6, never, string[]> | Request<'deckNamesAndIds', 6, never, Record<string, number>> | Request<'deleteDecks', 6, {
+    cardsToo: true;
+    decks: string[];
+}> | Request<'getDeckConfig', 6, {
+    deck: string;
+}, DeckConfig> | Request<'getDeckStats', 6, {
+    decks: string[];
+}, Record<string, DeckStats>> | Request<'getDecks', 6, Record<'cards', number[]>, Record<string, number[]>> | Request<'removeDeckConfigId', 6, {
+    configId: number;
+}, boolean> | Request<'saveDeckConfig', 6, {
+    config: DeckConfig;
+}, boolean> | Request<'setDeckConfigId', 6, {
+    configId: number;
+    decks: string[];
+}, boolean>;
+
+type NoteModel = 'Basic (and reversed card)' | 'Basic (type in the answer)' | 'Basic' | 'Cloze' | ({} & string);
+type NoteMedia = {
+    fields: string[];
+    filename: string;
+    skipHash?: false;
+    url: string;
+};
+type Note = {
+    audio?: NoteMedia[];
+    deckName: string;
+    fields: Record<string, string>;
+    modelName: NoteModel;
+    picture?: NoteMedia[];
+    tags?: string[];
+    video?: NoteMedia[];
+};
+type NoteWithCreationOptions = {
+    options?: {
+        allowDuplicate?: boolean;
+        duplicateScope?: 'deck' | ({} & string);
+        duplicateScopeOptions?: {
+            checkAllModels?: boolean;
+            checkChildren?: boolean;
+            deckName?: null | string;
+        };
+    };
+} & Note;
+type NoteRequests = Request<'addTags', 6, {
+    notes: number[];
+    tags: string;
+}> | Request<'canAddNotesWithErrorDetail', 6, {
+    notes: NoteWithCreationOptions[];
+}, Array<{
+    canAdd: false;
+    error: string;
+} | {
+    canAdd: true;
+}>> | Request<'findNotes', 6, {
+    query: string;
+}, number[]> | Request<'getNoteTags', 6, {
+    note: number;
+}, string[]> | Request<'notesInfo', 6, {
+    notes: number[];
+}, Array<{
+    cards: number[];
+    fields: Record<string, {
+        order: number;
+        value: string;
+    }>;
+    modelName: string;
+    noteId: number;
+    tags: string[];
+}>> | Request<'removeTags', 6, {
+    notes: number[];
+    tags: string;
+}> | Request<'replaceTags', 6, {
+    notes: number[];
+    replace_with_tag: string;
+    tag_to_replace: string;
+}> | Request<'replaceTagsInAllNotes', 6, {
+    replace_with_tag: string;
+    tag_to_replace: string;
+}> | Request<'updateNote', 6, {
+    note: {
+        audio?: NoteMedia[];
+        fields: Record<string, string>;
+        id: number;
+        picture?: NoteMedia[];
+        tags?: string[];
+        video?: NoteMedia[];
+    } | {
+        fields?: Record<string, string>;
+        id: number;
+        tags: string[];
+    };
+}> | Request<'updateNoteFields', 6, {
+    note: {
+        audio?: NoteMedia[];
+        fields: Record<string, string>;
+        id: number;
+        picture?: NoteMedia[];
+        video?: NoteMedia[];
+    };
+}> | Request<'updateNoteModel', 6, {
+    note: {
+        fields: Record<string, string>;
+        id: number;
+        modelName: string;
+        tags: string[];
+    };
+}> | Request<'updateNoteTags', 6, {
+    note: number;
+    tags: string[];
+}> | Request<'addNote', 6, {
+    note: NoteWithCreationOptions;
+}, null | number> | Request<'addNotes', 6, {
+    notes: NoteWithCreationOptions[];
+}, Array<null | string>> | Request<'canAddNotes', 6, {
+    notes: NoteWithCreationOptions[];
+}, boolean[]> | Request<'clearUnusedTags', 6, never, string[]> | Request<'deleteNotes', 6, {
+    notes: number[];
+}> | Request<'getTags', 6, never, string[]> | Request<'removeEmptyNotes', 6>;
+
+type GraphicalRequests = Request<'guiBrowse', 6, {
+    query: string;
+    reorderCards?: {
+        columnId: CardBrowserColumns;
+        order: 'ascending' | 'descending';
+    };
+}, number[]> | Request<'guiAddCards', 6, {
+    note: Note;
+}, number> | Request<'guiAnswerCard', 6, {
+    ease: number;
+}, boolean> | Request<'guiCheckDatabase', 6, never, true> | Request<'guiCurrentCard', 6, never, CardInfo | null> | Request<'guiDeckBrowser', 6> | Request<'guiDeckOverview', 6, {
+    name: string;
+}, boolean> | Request<'guiDeckReview', 6, {
+    name: string;
+}, boolean> | Request<'guiEditNote', 6, {
+    note: number;
+}> | Request<'guiExitAnki', 6> | Request<'guiImportFile', 6, {
+    path: string;
+}> | Request<'guiSelectNote', 6, {
+    note: number;
+}, boolean> | Request<'guiSelectedNotes', 6, never, number[]> | Request<'guiShowAnswer', 6, never, boolean> | Request<'guiShowQuestion', 6, never, boolean> | Request<'guiStartCardTimer', 6, never, true> | Request<'guiUndo', 6, never, boolean>;
+
+type MediaRequests = Request<'retrieveMediaFile', 6, {
+    filename: string;
+}, false | string> | Request<'storeMediaFile', 6, {
+    data: string;
+    deleteExisting: boolean;
+    filename: string;
+    path: string;
+    url: string;
+}, string> | Request<'deleteMediaFile', 6, {
+    filename: string;
+}> | Request<'getMediaDirPath', 6, never, string> | Request<'getMediaFilesNames', 6, {
+    pattern: string;
+}, string[]>;
+
+type MiscellaneousRequests = Request<'apiReflect', 6, {
+    actions: null | string[];
+    scopes: Array<'actions'>;
+}, {
+    actions: string[];
+    scopes: string[];
+}> | Request<'exportPackage', 6, {
+    deck: string;
+    includeSched?: boolean;
+    path: string;
+}, boolean> | Request<'importPackage', 6, {
+    path: string;
+}, boolean> | Request<'multi', 6, // Crazy, have to call this experimental
+{
+    actions: Array<{
+        action: Requests['action'];
+        params?: Requests['params'];
+        version?: number;
+    }>;
+}, Array<{
+    error: null | string;
+    result: Requests['response'];
+} | Requests['response']>> | Request<'requestPermission', 6, never, {
+    permission: 'denied';
+} | {
+    permission: 'granted';
+    requireApiKey: boolean;
+    version: boolean;
+}> | Request<'getProfiles', 6, never, string[]> | Request<'loadProfile', 6, {
+    name: string;
+}, true> | Request<'reloadCollection', 6> | Request<'sync', 6> | Request<'version', 6, never, number>;
+
+type ModelField = {
+    collapsed: boolean;
+    description: string;
+    excludeFromSearch: boolean;
+    font: string;
+    id: number;
+    name: string;
+    ord: number;
+    plainText: boolean;
+    preventDeletion: boolean;
+    rtl: boolean;
+    size: number;
+    sticky: boolean;
+    tag: null;
+};
+type ModelTemplate = {
+    afmt: string;
+    bafmt: string;
+    bfont: string;
+    bqfmt: string;
+    bsize: number;
+    did: null;
+    id: number;
+    name: string;
+    ord: number;
+    qfmt: string;
+};
+type Model = {
+    css: string;
+    did: null;
+    flds: ModelField[];
+    id: number;
+    latexPost: string;
+    latexPre: string;
+    latexsvg: boolean;
+    mod: number;
+    name: string;
+    originalStockKind: number;
+    req: Array<[number, string, number[]]>;
+    sortf: number;
+    tmpls: ModelTemplate[];
+    type: number;
+    usn: number;
+};
+type ModelToCreate = {
+    cardTemplates: Array<{
+        [key: string]: string;
+        Back: string;
+        Front: string;
+    }>;
+    css?: string;
+    inOrderFields: string[];
+    isCloze?: boolean;
+    modelName: string;
+};
+type ModelRequests = Request<'findAndReplaceInModels', 6, {
+    model: {
+        back: boolean;
+        css: boolean;
+        fieldText: string;
+        front: boolean;
+        modelName: string;
+        replaceText: string;
+    };
+}, number> | Request<'modelFieldDescriptions', 6, {
+    description: string;
+    fieldName: string;
+    modelName: string;
+}, boolean> | Request<'modelFieldFonts', 6, {
+    modelName: string;
+}, Record<string, {
+    font: string;
+    size: number;
+}>> | Request<'modelFieldRename', 6, {
+    modelName: string;
+    newFieldName: string;
+    oldFieldName: string;
+}> | Request<'modelFieldsOnTemplates', 6, {
+    modelName: string;
+}, Record<string, [string[], string[]]>> | Request<'modelTemplateAdd', 6, {
+    modelName: string;
+    template: {
+        [key: string]: string;
+        Back: string;
+        Front: string;
+    };
+}> | Request<'modelTemplateRemove', 6, {
+    modelName: string;
+    templateName: string;
+}> | Request<'modelTemplateRename', 6, {
+    modelName: string;
+    newTemplateName: string;
+    oldTemplateName: string;
+}> | Request<'modelTemplateReposition', 6, {
+    index: number;
+    modelName: string;
+    templateName: string;
+}> | Request<'modelTemplates', 6, {
+    modelName: string;
+}, Record<string, {
+    [key: string]: string;
+    Back: string;
+    Front: string;
+}>> | Request<'updateModelStyling', 6, {
+    model: {
+        css: string;
+        name: string;
+    };
+}> | Request<'updateModelTemplates', 6, {
+    model: {
+        name: string;
+        templates: Record<string, {
+            Back?: string;
+            Front?: string;
+        }>;
+    };
+}> | Request<'createModel', 6, ModelToCreate, Model> | Request<'findModelsById', 6, {
+    modelIds: number[];
+}, Model[]> | Request<'findModelsByName', 6, {
+    modelNames: string[];
+}, Model[]> | Request<'modelFieldAdd', 6, {
+    fieldName: string;
+    index: number;
+    modelName: string;
+}> | Request<'modelFieldNames', 6, {
+    modelName: string;
+}, string[]> | Request<'modelFieldRemove', 6, {
+    fieldName: string;
+    modelName: string;
+}> | Request<'modelFieldReposition', 6, {
+    fieldName: string;
+    index: number;
+    modelName: string;
+}> | Request<'modelFieldSetDescription', 6, {
+    fieldName: string;
+    index: number;
+    modelName: string;
+}> | Request<'modelFieldSetFont', 6, {
+    fieldName: string;
+    font: string;
+    modelName: string;
+}> | Request<'modelFieldSetFontSize', 6, {
+    fieldName: string;
+    fontSize: number;
+    modelName: string;
+}> | Request<'modelNames', 6, never, string[]> | Request<'modelNamesAndIds', 6, never, Record<string, number>> | Request<'modelStyling', 6, {
+    modelName: string;
+}, {
+    css: string;
+}>;
+
+/**
+ * Abstract wrapper over an Anki Connect action / response
+ */
+type Request<Action extends string, Version extends AnkiConnectVersion, Params = never, Result = null> = {
+    action: Action;
+    params: Params;
+    response: {
+        error: null | string;
+        result: Result;
+    };
+    version: Version;
+};
+/**
+ * Requests
+ */
+type Requests = CardRequests | DeckRequests | GraphicalRequests | MediaRequests | MiscellaneousRequests | ModelRequests | NoteRequests | StatisticRequests;
+type AnkiConnectVersion = 6;
+type ParamsForAction<T extends Requests['action']> = Extract<Requests, {
+    action: T;
+}>['params'];
+
+type ReviewStatisticTuple = [
+    reviewTime: number,
+    cardID: number,
+    usn: number,
+    buttonPressed: number,
+    newInterval: number,
+    previousInterval: number,
+    newFactor: number,
+    reviewDuration: number,
+    reviewType: number
+];
+type StatisticRequests = Request<'cardReviews', 6, {
+    deck: string;
+    startID: number;
+}, ReviewStatisticTuple[]> | Request<'getReviewsOfCards', 6, {
+    cards: string[];
+}, Record<string, Array<{
+    /** ButtonPressed */
+    ease: number;
+    /** NewFactor */
+    factor: number;
+    /** ReviewTime */
+    id: number;
+    /** NewInterval */
+    ivl: number;
+    /** PreviousInterval */
+    lastIvl: number;
+    /** ReviewDuration */
+    time: number;
+    /** ReviewType */
+    type: number;
+    /** Usn */
+    usn: number;
+}>>> | Request<'getCollectionStatsHTML', 6, {
+    wholeCollection: boolean;
+}, string> | Request<'getLatestReviewID', 6, {
+    deck: string;
+}, number> | Request<'getNumCardsReviewedByDay', 6, never, Array<[string, number]>> | Request<'getNumCardsReviewedToday', 6, never, number> | Request<'insertReviews', 6, {
+    reviews: ReviewStatisticTuple[];
+}>;
+
+/**
+ * Subset of built-in Fetch interface that's actually used by Anki, for ease of
+ * external re-implementation when passing a custom fetch function to
+ * YankiClient.
+ */
+type YankiFetch = (input: string, init: {
+    body: string;
+    headers: Record<string, string>;
+    method: string;
+    mode: RequestMode;
+}) => Promise<{
+    json(): Promise<any>;
+    status: number;
+} | undefined>;
+/** Optional options to pass when instantiating a new YankiConnect instance. */
+type YankiConnectOptions = {
+    /**
+     * Attempt to open the desktop Anki.app if it's not already running.
+     *
+     * - `true` will always attempt to open Anki _when a request is made_. This
+     *   might introduce significant latency on the first launch.
+     * - `false` will never attempt to open Anki. Requests will fail until
+     *   something or someone else opens the Anki app.
+     * -  `immediately` is a special option that will open Anki when the client is
+     *    instantiated.
+     *
+     * The Anki desktop app must be running for the client and the underlying
+     * AnkiConnect service to work.
+     *
+     * Currently supported on macOS only.
+     *
+     * The client does not attempt to close the app.
+     *
+     * @default false
+     */
+    autoLaunch: 'immediately' | boolean;
+    /**
+     * Advanced option to customize the resource fetch implementation used to make requests to Anki-Connect.
+     *
+     * Note that the signature reflects the subset of the built-in Fetch interface that's actually used by yanki-connect.
+     *
+     * The exact signature of this option is subject to change in the future.
+     *
+     * @default fetch
+     */
+    customFetch: YankiFetch | undefined;
+    /**
+     * Host where the Anki-Connect service is running.
+     *
+     * @default 'http://127.0.0.1'
+     */
+    host: string;
+    /**
+     * Anki-Connect security key (optional)
+     *
+     * @default undefined
+     */
+    key: string | undefined;
+    /**
+     * Port where the Anki-Connect service is running.
+     *
+     * @default 8765
+     */
+    port: number;
+    /**
+     * Anki-Connect API version.
+     *
+     * Only API version 6 is supported for now.
+     *
+     * @default 6
+     */
+    version: AnkiConnectVersion;
+};
+
+declare const yankiModels: [{
+    readonly cardTemplates: [{
+        readonly Back: "{{FrontSide}}\n\n<hr id=answer>\n\n{{Back}}";
+        readonly Front: "{{Front}}";
+        readonly YankiNamespace: "{{YankiNamespace}}";
+    }];
+    readonly inOrderFields: ["Front", "Back", "YankiNamespace"];
+    readonly modelName: "Yanki - Basic";
+}, {
+    readonly cardTemplates: [{
+        readonly Back: "{{FrontSide}}\n\n<hr id=answer>\n\n{{Back}}";
+        readonly Front: "{{Front}}";
+        readonly YankiNamespace: "{{YankiNamespace}}";
+    }, {
+        readonly Back: "{{FrontSide}}\n\n<hr id=answer>\n\n{{Front}}";
+        readonly Front: "{{Back}}";
+        readonly YankiNamespace: "{{YankiNamespace}}";
+    }];
+    readonly inOrderFields: ["Front", "Back", "YankiNamespace"];
+    readonly modelName: "Yanki - Basic (and reversed card)";
+}, {
+    readonly cardTemplates: [{
+        readonly Back: "{{cloze:Front}}<br>\n{{Back}}";
+        readonly Front: "{{cloze:Front}}";
+        readonly YankiNamespace: "{{YankiNamespace}}";
+    }];
+    readonly inOrderFields: ["Front", "Back", "YankiNamespace"];
+    readonly isCloze: true;
+    readonly modelName: "Yanki - Cloze";
+}, {
+    readonly cardTemplates: [{
+        readonly Back: "{{Front}}\n\n<hr id=answer>\n\n{{type:Back}}";
+        readonly Front: "{{Front}}\n\n{{type:Back}}";
+        readonly YankiNamespace: "{{YankiNamespace}}";
+    }];
+    readonly inOrderFields: ["Front", "Back", "YankiNamespace"];
+    readonly modelName: "Yanki - Basic (type in the answer)";
+}];
+type YankiModelName = (typeof yankiModels)[number]['modelName'];
+
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+type Primitive =
+	| null
+	| undefined
+	| string
+	| number
+	| boolean
+	| symbol
+	| bigint;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see SimplifyDeep
+@category Object
+*/
+type Simplify<T> = {[KeyType in keyof T]: T[KeyType]} & {};
+
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+type BuiltIns = Primitive | void | Date | RegExp;
+
+/**
+@see PartialDeep
+*/
+type PartialDeepOptions = {
+	/**
+	Whether to affect the individual elements of arrays and tuples.
+
+	@default false
+	*/
+	readonly recurseIntoArrays?: boolean;
+};
+
+/**
+Create a type from another type with all keys and nested keys set to optional.
+
+Use-cases:
+- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
+- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
+
+@example
+```
+import type {PartialDeep} from 'type-fest';
+
+const settings: Settings = {
+	textEditor: {
+		fontSize: 14;
+		fontColor: '#000000';
+		fontWeight: 400;
+	}
+	autocomplete: false;
+	autosave: true;
+};
+
+const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
+	return {...settings, ...savedSettings};
+}
+
+settings = applySavedSettings({textEditor: {fontWeight: 500}});
+```
+
+By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
+
+```
+import type {PartialDeep} from 'type-fest';
+
+interface Settings {
+	languages: string[];
+}
+
+const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
+	languages: [undefined]
+};
+```
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends BuiltIns | (((...arguments_: any[]) => unknown)) | (new (...arguments_: any[]) => unknown)
+	? T
+	: T extends Map<infer KeyType, infer ValueType>
+		? PartialMapDeep<KeyType, ValueType, Options>
+		: T extends Set<infer ItemType>
+			? PartialSetDeep<ItemType, Options>
+			: T extends ReadonlyMap<infer KeyType, infer ValueType>
+				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
+				: T extends ReadonlySet<infer ItemType>
+					? PartialReadonlySetDeep<ItemType, Options>
+					: T extends object
+						? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+							? Options['recurseIntoArrays'] extends true
+								? ItemType[] extends T // Test for arrays (non-tuples) specifically
+									? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
+										? ReadonlyArray<PartialDeep<ItemType | undefined, Options>>
+										: Array<PartialDeep<ItemType | undefined, Options>>
+									: PartialObjectDeep<T, Options> // Tuples behave properly
+								: T // If they don't opt into array testing, just use the original type
+							: PartialObjectDeep<T, Options>
+						: unknown;
+
+/**
+Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> = {} & Map<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialSetDeep<T, Options extends PartialDeepOptions> = {} & Set<PartialDeep<T, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlyMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> = {} & ReadonlyMap<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlySetDeep<T, Options extends PartialDeepOptions> = {} & ReadonlySet<PartialDeep<T, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialObjectDeep<ObjectType extends object, Options extends PartialDeepOptions> = {
+	[KeyType in keyof ObjectType]?: PartialDeep<ObjectType[KeyType], Options>
+};
+
+type YankiNote = Simplify<{
+    cards?: number[];
+    fields: {
+        Back: string;
+        Front: string;
+        YankiNamespace: string;
+    };
+    modelName: YankiModelName;
+    noteId: number | undefined;
+} & Omit<ParamsForAction<'addNote'>['note'], 'fields' | 'modelName' | 'options'>>;
+
+declare const defaultCleanOptions: CleanOptions;
+type CleanOptions = {
+    ankiConnectOptions: YankiConnectOptions;
+    /**
+     * Automatically sync any changes to AnkiWeb after Yanki has finished syncing
+     * locally. If false, only local Anki data is updated and you must manually
+     * invoke a sync to AnkiWeb. This is the equivalent of pushing the "sync"
+     * button in the Anki app.
+     */
+    ankiWeb: boolean;
+    dryRun: boolean;
+    namespace: string;
+};
+type CleanReport = {
+    ankiWeb: boolean;
+    decks: string[];
+    deleted: YankiNote[];
+    dryRun: boolean;
+    duration: number;
+    namespace: string;
+};
+/**
+ * Deletes all remote notes in Anki associated with the given namespace.
+ *
+ * Use with significant caution. Mostly useful for testing.
+ *
+ * @returns The IDs of the notes that were deleted
+ * @param options
+ * @throws
+ */
+declare function cleanNotes(options?: PartialDeep<CleanOptions>): Promise<CleanReport>;
+declare function formatCleanReport(report: CleanReport, verbose?: boolean): string;
+
+type ListOptions = {
+    ankiConnectOptions: YankiConnectOptions;
+    namespace: string;
+};
+declare const defaultListOptions: ListOptions;
+type ListReport = {
+    duration: number;
+    namespace: string;
+    notes: YankiNote[];
+};
+/**
+ * Description List notes...
+ * @param options
+ * @returns
+ */
+declare function listNotes(options?: PartialDeep<ListOptions>): Promise<ListReport>;
+declare function formatListReport(report: ListReport): string;
+
+type StyleOptions = {
+    ankiConnectOptions: YankiConnectOptions;
+    /**
+     * Automatically sync any changes to AnkiWeb after Yanki has finished syncing
+     * locally. If false, only local Anki data is updated and you must manually
+     * invoke a sync to AnkiWeb. This is the equivalent of pushing the "sync"
+     * button in the Anki app.
+     */
+    ankiWeb: boolean;
+    css: string;
+    dryRun: boolean;
+};
+declare const defaultStyleOptions: StyleOptions;
+type StyleReport = {
+    ankiWeb: boolean;
+    dryRun: boolean;
+    duration: number;
+    models: Array<{
+        action: 'unchanged' | 'updated';
+        name: string;
+    }>;
+};
+declare function setStyle(options: PartialDeep<StyleOptions>): Promise<StyleReport>;
+declare function formatStyleReport(report: StyleReport, verbose?: boolean): string;
+
+type SyncedNote = {
+    action: 'created' | 'deleted' | 'recreated' | 'unchanged' | 'updated';
+    filePath?: string;
+    note: YankiNote;
+};
+type SyncOptions = {
+    ankiConnectOptions: YankiConnectOptions;
+    /**
+     * Automatically sync any changes to AnkiWeb after Yanki has finished syncing
+     * locally. If false, only local Anki data is updated and you must manually
+     * invoke a sync to AnkiWeb. This is the equivalent of pushing the "sync"
+     * button in the Anki app.
+     */
+    ankiWeb: boolean;
+    defaultDeckName: string;
+    dryRun: boolean;
+    namespace: string;
+    /** Ensures that wiki-style links work correctly */
+    obsidianVault: string | undefined;
+};
+declare const defaultSyncOptions: SyncOptions;
+type SyncReport = {
+    ankiWeb: boolean;
+    deletedDecks: string[];
+    dryRun: boolean;
+    duration: number;
+    namespace: string;
+    synced: SyncedNote[];
+};
+/**
+ * Syncs local notes to Anki.
+ *
+ * @param allLocalNotes All the YankiNotes to sync
+ * @returns The synced notes (with new IDs where applicable), plus some stats
+ * about the sync @throws
+ */
+declare function syncNotes(allLocalNotes: YankiNote[], options?: PartialDeep<SyncOptions>): Promise<SyncReport>;
+/**
+ * Sync a list of local yanki files to Anki.
+ *
+ * Wraps the syncNotes function to handle file I/O.
+ *
+ * Most importantly, it updates the note IDs in the frontmatter of the local
+ * files.
+ *
+ * @param allLocalFilePaths Array of paths to the local markdown files
+ * @returns The synced files (with new IDs where applicable), plus some stats
+ * about the sync @throws
+ */
+declare function syncFiles(allLocalFilePaths: string[], options?: PartialDeep<SyncOptions>, readFile?: (filePath: string) => Promise<string>, writeFile?: (filePath: string, data: string) => Promise<void>): Promise<SyncReport>;
+/**
+ * Helper function to infer deck names from file paths if `deckName` not defined in the note's frontmatter.
+ *
+ * `deckName` will always override the inferred deck name.
+ *
+ * Depends on the context of _all_ file paths passed to `syncNoteFiles`.
+ *
+ * Example of paths -> deck names with `common-root`:
+ * /base/foo/note.md -> foo
+ * /base/foo/baz/note.md -> foo::baz
+ *
+ * Example of paths -> deck names with `common-root`:
+ * /base/foo/note.md -> foo
+ * /base/foo/note.md -> foo
+ *
+ * Example of paths -> deck names with `common-parent`:
+ * /base/foo/note.md -> base::foo
+ * /base/foo/baz/note.md -> base::foo::baz
+ *
+ * Example of paths -> deck names with `common-parent`:
+ * /base/foo/note.md -> foo
+ * /base/foo/note.md -> foo
+ *
+ * @param absoluteFilePaths Absolute paths to all markdown Anki note files. (Ensures proper resolution if path module is polyfilled.)
+ * @param prune If true, deck names are not allowed to "jump" over empty directories, even if there are other note files somewhere up the hierarchy
+ * @returns array of ::-delimited deck paths
+ */
+declare function getDeckNamesFromFilePaths(absoluteFilePaths: string[], mode?: 'common-parent' | 'common-root'): string[];
+declare function formatSyncReport(report: SyncReport, verbose?: boolean): string;
+
+/**
+ * Helpers for working with the Markdown AST.
+ */
+
+type AstFromMarkdownOptions = {
+    obsidianVault?: string;
+};
+
+/**
+ * Turns a markdown string into a YankiNote object.
+ */
+
+type NoteFromMarkdownOptions = {
+    namespace: string;
+} & AstFromMarkdownOptions;
+declare function getNoteFromMarkdown(markdown: string, options: NoteFromMarkdownOptions): Promise<YankiNote>;
+
+declare function urlToHostAndPort(url: string): {
+    host: string;
+    port: number;
+};
+declare function hostAndPortToUrl(host: string, port: number): string;
+
+export { type CleanOptions, type CleanReport, type ListOptions, type StyleOptions, type StyleReport, type SyncOptions, type SyncReport, type YankiNote, cleanNotes, defaultCleanOptions, defaultListOptions, defaultStyleOptions, defaultSyncOptions, formatCleanReport, formatListReport, formatStyleReport, formatSyncReport, getDeckNamesFromFilePaths, getNoteFromMarkdown, hostAndPortToUrl, listNotes, setStyle, syncFiles, syncNotes, urlToHostAndPort };