@saeris/tmdbkit 0.0.0 → 0.1.0

package/dist/types/Video.d.mts

@@ -0,0 +1,51 @@
+import * as v from "valibot";
+export declare const videoEntries: {
+  readonly id: v.StringSchema<undefined>;
+  readonly iso_3166_1: v.StringSchema<undefined>;
+  readonly iso_639_1: v.StringSchema<undefined>;
+  /** The video's id on `site` (for YouTube, the `v=` value). */
+  readonly key: v.StringSchema<undefined>;
+  readonly name: v.StringSchema<undefined>;
+  readonly official: v.BooleanSchema<undefined>;
+  /** ISO 8601 timestamp. */
+  readonly publishedAt: v.StringSchema<undefined>;
+  /** Where the video is hosted, e.g. `YouTube`. */
+  readonly site: v.StringSchema<undefined>;
+  /** Vertical resolution, e.g. `1080`. */
+  readonly size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
+  /** `Trailer`, `Teaser`, `Clip`, `Featurette`, `Behind the Scenes`, … */
+  readonly type: v.StringSchema<undefined>;
+};
+declare const _videoSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly iso_3166_1: v.StringSchema<undefined>;
+  readonly iso_639_1: v.StringSchema<undefined>;
+  /** The video's id on `site` (for YouTube, the `v=` value). */
+  readonly key: v.StringSchema<undefined>;
+  readonly name: v.StringSchema<undefined>;
+  readonly official: v.BooleanSchema<undefined>;
+  /** ISO 8601 timestamp. */
+  readonly publishedAt: v.StringSchema<undefined>;
+  /** Where the video is hosted, e.g. `YouTube`. */
+  readonly site: v.StringSchema<undefined>;
+  /** Vertical resolution, e.g. `1080`. */
+  readonly size: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
+  /** `Trailer`, `Teaser`, `Clip`, `Featurette`, `Behind the Scenes`, … */
+  readonly type: v.StringSchema<undefined>;
+}, undefined>;
+export interface Video extends v.InferOutput<typeof _videoSchema> {}
+/**
+ * ### Video
+ *
+ * A trailer, teaser, clip or featurette hosted elsewhere (usually YouTube).
+ */
+export declare const videoSchema: v.GenericSchema<Video>;
+declare const _videosSchema: v.ObjectSchema<{
+  readonly id: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
+  readonly results: v.ArraySchema<v.GenericSchema<Video>, undefined>;
+}, undefined>;
+export interface Videos extends v.InferOutput<typeof _videosSchema> {}
+/** The videos of a movie, TV series, season or episode. */
+export declare const videosSchema: v.GenericSchema<Videos>;
+export {};
+//# sourceMappingURL=Video.d.mts.map

package/dist/types/Video.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Video.d.mts","names":[],"sources":["../../src/types/Video.ts"],"mappings":";qBAIa;;;;;;;;;;;;;;;;;cAkBP,cAAY,EAAA;;;;;;;;;;;;;;;;;iBAED,cAAc,EAAE,mBAAmB;;;;;;qBAOvC,aAAW,EAAA,cAAA;cAElB,eAAa,EAAA;;;;iBAEF,eAAe,EAAE,mBAAmB;;qBAGxC,cAAY,EAAA,cAAA"}

package/dist/types/Video.mjs

@@ -0,0 +1,37 @@
+import { schema } from "../validations/schema.mjs";
+import { integer } from "../validations/integer.mjs";
+import * as v from "valibot";
+// src/types/Video.ts
+const videoEntries = {
+	id: v.string(),
+	iso_3166_1: v.string(),
+	iso_639_1: v.string(),
+	/** The video's id on `site` (for YouTube, the `v=` value). */
+	key: v.string(),
+	name: v.string(),
+	official: v.boolean(),
+	/** ISO 8601 timestamp. */
+	publishedAt: v.string(),
+	/** Where the video is hosted, e.g. `YouTube`. */
+	site: v.string(),
+	/** Vertical resolution, e.g. `1080`. */
+	size: integer,
+	/** `Trailer`, `Teaser`, `Clip`, `Featurette`, `Behind the Scenes`, … */
+	type: v.string()
+};
+const _videoSchema = v.object(videoEntries);
+/**
+* ### Video
+*
+* A trailer, teaser, clip or featurette hosted elsewhere (usually YouTube).
+*/
+const videoSchema = schema(_videoSchema);
+const _videosSchema = v.object({
+	id: integer,
+	results: v.array(videoSchema)
+});
+/** The videos of a movie, TV series, season or episode. */
+const videosSchema = schema(_videosSchema);
+export { videoEntries, videoSchema, videosSchema };
+
+//# sourceMappingURL=Video.mjs.map

package/dist/types/Video.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Video.mjs","names":[],"sources":["../../src/types/Video.ts"],"sourcesContent":["import * as v from \"valibot\";\nimport { schema } from \"../validations/schema.js\";\nimport { integer } from \"../validations/integer.js\";\n\nexport const videoEntries = {\n  id: v.string(),\n  iso_3166_1: v.string(),\n  iso_639_1: v.string(),\n  /** The video's id on `site` (for YouTube, the `v=` value). */\n  key: v.string(),\n  name: v.string(),\n  official: v.boolean(),\n  /** ISO 8601 timestamp. */\n  publishedAt: v.string(),\n  /** Where the video is hosted, e.g. `YouTube`. */\n  site: v.string(),\n  /** Vertical resolution, e.g. `1080`. */\n  size: integer,\n  /** `Trailer`, `Teaser`, `Clip`, `Featurette`, `Behind the Scenes`, … */\n  type: v.string()\n} as const;\n\nconst _videoSchema = v.object(videoEntries);\n\nexport interface Video extends v.InferOutput<typeof _videoSchema> {}\n\n/**\n * ### Video\n *\n * A trailer, teaser, clip or featurette hosted elsewhere (usually YouTube).\n */\nexport const videoSchema = schema<Video>(_videoSchema);\n\nconst _videosSchema = v.object({ id: integer, results: v.array(videoSchema) });\n\nexport interface Videos extends v.InferOutput<typeof _videosSchema> {}\n\n/** The videos of a movie, TV series, season or episode. */\nexport const videosSchema = schema<Videos>(_videosSchema);\n"],"mappings":";;;;AAIA,MAAa,eAAe;CAC1B,IAAI,EAAE,OAAO;CACb,YAAY,EAAE,OAAO;CACrB,WAAW,EAAE,OAAO;;CAEpB,KAAK,EAAE,OAAO;CACd,MAAM,EAAE,OAAO;CACf,UAAU,EAAE,QAAQ;;CAEpB,aAAa,EAAE,OAAO;;CAEtB,MAAM,EAAE,OAAO;;CAEf,MAAM;;CAEN,MAAM,EAAE,OAAO;AACjB;AAEA,MAAM,eAAe,EAAE,OAAO,YAAY;;;;;;AAS1C,MAAa,cAAc,OAAc,YAAY;AAErD,MAAM,gBAAgB,EAAE,OAAO;CAAE,IAAI;CAAS,SAAS,EAAE,MAAM,WAAW;AAAE,CAAC;;AAK7E,MAAa,eAAe,OAAe,aAAa"}

package/dist/types/index.d.mts

@@ -0,0 +1,15 @@
+import { Image, LogoImage, LogoImages, MediaImages, PosterImages, ProfileImages, StillImages, imageEntries, imageSchema, logoImageEntries, logoImageSchema, logoImagesSchema, mediaImagesSchema, posterImagesSchema, profileImagesSchema, stillImagesSchema } from "./Images.mjs";
+import { Translation, Translations, translation, translations } from "./Translation.mjs";
+import { PagedResults, pageEntries, pagedResults } from "./PagedResults.mjs";
+import { AlternativeNames, alternativeNamesSchema } from "./AlternativeNames.mjs";
+import { ProductionCompany, productionCompanyEntries, productionCompanySchema } from "./ProductionCompany.mjs";
+import { SpokenLanguage, spokenLanguageEntries, spokenLanguageSchema } from "./SpokenLanguage.mjs";
+import { Keyword, PagedKeywordResults, keywordEntries, keywordSchema, pagedKeywordResultsSchema } from "./Keyword.mjs";
+import { ChangeList, ChangedItem, changeListSchema } from "./ChangeList.mjs";
+import { Changes, changeItemEntries, changesSchema } from "./Changes.mjs";
+import { Video, Videos, videoEntries, videoSchema, videosSchema } from "./Video.mjs";
+import { MediaListItem, PagedMediaResults, mediaListItemSchema, pagedMediaResultsSchema } from "./MediaListItem.mjs";
+import { CastCredit, CrewCredit, castCreditEntries, castCreditSchema, creditPersonEntries, crewCreditEntries, crewCreditSchema } from "./Credit.mjs";
+import { Genre, genreEntries, genreSchema } from "./Genre.mjs";
+import { ProductionCountry, productionCountryEntries, productionCountrySchema } from "./ProductionCountry.mjs";
+export { AlternativeNames, CastCredit, ChangeList, ChangedItem, Changes, CrewCredit, Genre, Image, Keyword, LogoImage, LogoImages, MediaImages, MediaListItem, PagedKeywordResults, PagedMediaResults, PagedResults, PosterImages, ProductionCompany, ProductionCountry, ProfileImages, SpokenLanguage, StillImages, Translation, Translations, Video, Videos, alternativeNamesSchema, castCreditEntries, castCreditSchema, changeItemEntries, changeListSchema, changesSchema, creditPersonEntries, crewCreditEntries, crewCreditSchema, genreEntries, genreSchema, imageEntries, imageSchema, keywordEntries, keywordSchema, logoImageEntries, logoImageSchema, logoImagesSchema, mediaImagesSchema, mediaListItemSchema, pageEntries, pagedKeywordResultsSchema, pagedMediaResultsSchema, pagedResults, posterImagesSchema, productionCompanyEntries, productionCompanySchema, productionCountryEntries, productionCountrySchema, profileImagesSchema, spokenLanguageEntries, spokenLanguageSchema, stillImagesSchema, translation, translations, videoEntries, videoSchema, videosSchema };

package/dist/types/index.mjs

@@ -0,0 +1,15 @@
+import { pageEntries, pagedResults } from "./PagedResults.mjs";
+import { translation, translations } from "./Translation.mjs";
+import { productionCompanyEntries, productionCompanySchema } from "./ProductionCompany.mjs";
+import { spokenLanguageEntries, spokenLanguageSchema } from "./SpokenLanguage.mjs";
+import { genreEntries, genreSchema } from "./Genre.mjs";
+import { castCreditEntries, castCreditSchema, creditPersonEntries, crewCreditEntries, crewCreditSchema } from "./Credit.mjs";
+import { changeItemEntries, changesSchema } from "./Changes.mjs";
+import { imageEntries, imageSchema, logoImageEntries, logoImageSchema, logoImagesSchema, mediaImagesSchema, posterImagesSchema, profileImagesSchema, stillImagesSchema } from "./Images.mjs";
+import { productionCountryEntries, productionCountrySchema } from "./ProductionCountry.mjs";
+import { videoEntries, videoSchema, videosSchema } from "./Video.mjs";
+import { keywordEntries, keywordSchema, pagedKeywordResultsSchema } from "./Keyword.mjs";
+import { alternativeNamesSchema } from "./AlternativeNames.mjs";
+import { changeListSchema } from "./ChangeList.mjs";
+import { mediaListItemSchema, pagedMediaResultsSchema } from "./MediaListItem.mjs";
+export { alternativeNamesSchema, castCreditEntries, castCreditSchema, changeItemEntries, changeListSchema, changesSchema, creditPersonEntries, crewCreditEntries, crewCreditSchema, genreEntries, genreSchema, imageEntries, imageSchema, keywordEntries, keywordSchema, logoImageEntries, logoImageSchema, logoImagesSchema, mediaImagesSchema, mediaListItemSchema, pageEntries, pagedKeywordResultsSchema, pagedMediaResultsSchema, pagedResults, posterImagesSchema, productionCompanyEntries, productionCompanySchema, productionCountryEntries, productionCountrySchema, profileImagesSchema, spokenLanguageEntries, spokenLanguageSchema, stillImagesSchema, translation, translations, videoEntries, videoSchema, videosSchema };

package/dist/utils/isNonNullable.d.mts

@@ -0,0 +1,8 @@
+export type Maybe<T> = T | null | undefined;
+/**
+ * Used to test whether a `Maybe` typed value is `null` or `undefined`.
+ *
+ * When called, the given value's type is narrowed to `NonNullable<T>`.
+ */
+export declare const isNonNullable: <T extends Maybe<unknown>>(val?: T) => val is NonNullable<T>;
+//# sourceMappingURL=isNonNullable.d.mts.map

package/dist/utils/isNonNullable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNonNullable.d.mts","names":[],"sources":["../../src/utils/isNonNullable.ts"],"mappings":"A,YAAY,MAAM,KAAK;;;;;;qBAOV,gBAAiB,UAAU,gBACtC,MAAM,MACL,OAAO,YAAY"}

package/dist/utils/isNonNullable.mjs

@@ -0,0 +1,10 @@
+// src/utils/isNonNullable.ts
+/**
+* Used to test whether a `Maybe` typed value is `null` or `undefined`.
+*
+* When called, the given value's type is narrowed to `NonNullable<T>`.
+*/
+const isNonNullable = (val) => typeof val !== `undefined` && val !== null;
+export { isNonNullable };
+
+//# sourceMappingURL=isNonNullable.mjs.map

package/dist/utils/isNonNullable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNonNullable.mjs","names":[],"sources":["../../src/utils/isNonNullable.ts"],"sourcesContent":["export type Maybe<T> = T | null | undefined;\n\n/**\n * Used to test whether a `Maybe` typed value is `null` or `undefined`.\n *\n * When called, the given value's type is narrowed to `NonNullable<T>`.\n */\nexport const isNonNullable = <T extends Maybe<unknown>>(\n  val?: T\n): val is NonNullable<T> => typeof val !== `undefined` && val !== null;\n"],"mappings":";;;;;;AAOA,MAAa,iBACX,QAC0B,OAAO,QAAQ,eAAe,QAAQ"}

package/dist/utils/isObject.d.mts

@@ -0,0 +1,2 @@
+export declare const isObject: (val: unknown) => val is Record<string, unknown>;
+//# sourceMappingURL=isObject.d.mts.map

package/dist/utils/isObject.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isObject.d.mts","names":[],"sources":["../../src/utils/isObject.ts"],"mappings":"A,qBAAa,WAAY,iBAAe,OAAO"}

package/dist/utils/isObject.mjs

@@ -0,0 +1,5 @@
+// src/utils/isObject.ts
+const isObject = (val) => Boolean(val) && typeof val === `object` && !Array.isArray(val);
+export { isObject };
+
+//# sourceMappingURL=isObject.mjs.map

package/dist/utils/isObject.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isObject.mjs","names":[],"sources":["../../src/utils/isObject.ts"],"sourcesContent":["export const isObject = (val: unknown): val is Record<string, unknown> =>\n  Boolean(val) && typeof val === `object` && !Array.isArray(val);\n"],"mappings":";AAAA,MAAa,YAAY,QACvB,QAAQ,GAAG,KAAK,OAAO,QAAQ,YAAY,CAAC,MAAM,QAAQ,GAAG"}

package/dist/utils/sleep.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Sleep for a given number of milliseconds. When a `signal` is given, the sleep rejects as soon as it aborts, so a cancelled request doesn't sit out a rate-limit or retry wait.
+ */
+export declare const sleep: (ms: number, signal?: AbortSignal) => Promise<void>;
+//# sourceMappingURL=sleep.d.mts.map

package/dist/utils/sleep.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.mts","names":[],"sources":["../../src/utils/sleep.ts"],"mappings":";;;qBAgBa,QAAe,YAAY,SAAS,gBAAc"}

package/dist/utils/sleep.mjs

@@ -0,0 +1,29 @@
+// src/utils/sleep.ts
+/**
+* The error a sleep rejects with when its signal aborts: the signal's own reason when that is an `Error` (by default a `DOMException` named `AbortError`), so callers can tell an abort from a failure by `name`.
+*/
+const abortError = (signal) => {
+	const reason = signal.reason;
+	return reason instanceof Error ? reason : new DOMException(typeof reason === `string` ? reason : `This operation was aborted`, `AbortError`);
+};
+/**
+* Sleep for a given number of milliseconds. When a `signal` is given, the sleep rejects as soon as it aborts, so a cancelled request doesn't sit out a rate-limit or retry wait.
+*/
+const sleep = async (ms, signal) => new Promise((resolve, reject) => {
+	if (signal?.aborted) {
+		reject(abortError(signal));
+		return;
+	}
+	const onAbort = () => {
+		clearTimeout(timer);
+		if (signal) reject(abortError(signal));
+	};
+	const timer = setTimeout(() => {
+		signal?.removeEventListener(`abort`, onAbort);
+		resolve();
+	}, Math.max(0, ms));
+	signal?.addEventListener(`abort`, onAbort, { once: true });
+});
+export { sleep };
+
+//# sourceMappingURL=sleep.mjs.map

package/dist/utils/sleep.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.mjs","names":[],"sources":["../../src/utils/sleep.ts"],"sourcesContent":["/**\n * The error a sleep rejects with when its signal aborts: the signal's own reason when that is an `Error` (by default a `DOMException` named `AbortError`), so callers can tell an abort from a failure by `name`.\n */\nconst abortError = (signal: AbortSignal): Error => {\n  const reason: unknown = signal.reason;\n  return reason instanceof Error\n    ? reason\n    : new DOMException(\n        typeof reason === `string` ? reason : `This operation was aborted`,\n        `AbortError`\n      );\n};\n\n/**\n * Sleep for a given number of milliseconds. When a `signal` is given, the sleep rejects as soon as it aborts, so a cancelled request doesn't sit out a rate-limit or retry wait.\n */\nexport const sleep = async (ms: number, signal?: AbortSignal): Promise<void> =>\n  new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(abortError(signal));\n      return;\n    }\n    const onAbort = (): void => {\n      clearTimeout(timer);\n      if (signal) reject(abortError(signal));\n    };\n    const timer = setTimeout(\n      () => {\n        signal?.removeEventListener(`abort`, onAbort);\n        resolve();\n      },\n      Math.max(0, ms)\n    );\n    signal?.addEventListener(`abort`, onAbort, { once: true });\n  });\n"],"mappings":";;;;AAGA,MAAM,cAAc,WAA+B;CACjD,MAAM,SAAkB,OAAO;CAC/B,OAAO,kBAAkB,QACrB,SACA,IAAI,aACF,OAAO,WAAW,WAAW,SAAS,8BACtC,YACF;AACN;;;;AAKA,MAAa,QAAQ,OAAO,IAAY,WACtC,IAAI,SAAS,SAAS,WAAW;CAC/B,IAAI,QAAQ,SAAS;EACnB,OAAO,WAAW,MAAM,CAAC;EACzB;CACF;CACA,MAAM,gBAAsB;EAC1B,aAAa,KAAK;EAClB,IAAI,QAAQ,OAAO,WAAW,MAAM,CAAC;CACvC;CACA,MAAM,QAAQ,iBACN;EACJ,QAAQ,oBAAoB,SAAS,OAAO;EAC5C,QAAQ;CACV,GACA,KAAK,IAAI,GAAG,EAAE,CAChB;CACA,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;AAC3D,CAAC"}

package/dist/utils/toCamelCase.d.mts

@@ -0,0 +1,8 @@
+/**
+ * camelCase a TMDB key: each `_` followed by a letter is dropped and the letter capitalised (`poster_path` → `posterPath`). Two kinds of key are left alone, by design (tmdbkit's plan, 2026-10-28):
+ *
+ * - an `_` before a digit, so ISO-code keys keep TMDB's documented names (`iso_3166_1`, not `iso31661`);
+ * - a leading `_`, which marks an internal key rather than a word break (`_id` stays `_id`).
+ */
+export declare const toCamelCase: (str: string) => string;
+//# sourceMappingURL=toCamelCase.d.mts.map

package/dist/utils/toCamelCase.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toCamelCase.d.mts","names":[],"sources":["../../src/utils/toCamelCase.ts"],"mappings":";;;;;;qBAMa,cAAe"}

package/dist/utils/toCamelCase.mjs

@@ -0,0 +1,11 @@
+// src/utils/toCamelCase.ts
+/**
+* camelCase a TMDB key: each `_` followed by a letter is dropped and the letter capitalised (`poster_path` → `posterPath`). Two kinds of key are left alone, by design (tmdbkit's plan, 2026-10-28):
+*
+* - an `_` before a digit, so ISO-code keys keep TMDB's documented names (`iso_3166_1`, not `iso31661`);
+* - a leading `_`, which marks an internal key rather than a word break (`_id` stays `_id`).
+*/
+const toCamelCase = (str) => str.replace(/(?<!^)_(?<char>[a-zA-Z])/g, (g) => g[1].toUpperCase());
+export { toCamelCase };
+
+//# sourceMappingURL=toCamelCase.mjs.map

package/dist/utils/toCamelCase.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toCamelCase.mjs","names":[],"sources":["../../src/utils/toCamelCase.ts"],"sourcesContent":["/**\n * camelCase a TMDB key: each `_` followed by a letter is dropped and the letter capitalised (`poster_path` → `posterPath`). Two kinds of key are left alone, by design (tmdbkit's plan, 2026-10-28):\n *\n * - an `_` before a digit, so ISO-code keys keep TMDB's documented names (`iso_3166_1`, not `iso31661`);\n * - a leading `_`, which marks an internal key rather than a word break (`_id` stays `_id`).\n */\nexport const toCamelCase = (str: string): string =>\n  str.replace(/(?<!^)_(?<char>[a-zA-Z])/g, (g) => g[1].toUpperCase());\n"],"mappings":";;;;;;;AAMA,MAAa,eAAe,QAC1B,IAAI,QAAQ,8BAA8B,MAAM,EAAE,EAAE,CAAC,YAAY,CAAC"}

package/dist/utils/toCamelKeys.d.mts

@@ -0,0 +1,17 @@
+/** Whether a one-character string is a letter (it has a case). */
+type IsLetter<C extends string> = Lowercase<C> extends Uppercase<C> ? false : true;
+/** {@link CamelCase} after any leading `_`: an `_` before a letter is dropped and the letter capitalised; an `_` before anything else stays. */
+type CamelTail<S extends string> = S extends `${infer Head}_${infer Tail}` ? Tail extends `${infer First}${string}` ? IsLetter<First> extends true ? `${Head}${CamelTail<Capitalize<Tail>>}` : `${Head}_${CamelTail<Tail>}` : S : S;
+/**
+ * Convert a `snake_case` string-literal type to `camelCase`, matching exactly what {@link toCamelCase} does at runtime: `poster_path` → `posterPath`, while `iso_3166_1` and `_id` are unchanged (see `toCamelCase` for why).
+ */
+type CamelCase<S extends string> = S extends `_${infer Rest}` ? `_${CamelTail<Rest>}` : CamelTail<S>;
+/**
+ * Recursively camel-case the keys of an object/array type. Mirrors
+ * {@link toCamelKeys}'s runtime: arrays map element-wise, plain objects remap
+ * their keys, and leaf values pass through unchanged.
+ */
+export type CamelKeys<T> = T extends ReadonlyArray<infer U> ? Array<CamelKeys<U>> : T extends object ? { [K in keyof T as K extends string ? CamelCase<K> : K]: CamelKeys<T[K]>; } : T;
+export declare const toCamelKeys: <T extends object>(o: T) => CamelKeys<T>;
+export {};
+//# sourceMappingURL=toCamelKeys.d.mts.map

package/dist/utils/toCamelKeys.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toCamelKeys.d.mts","names":[],"sources":["../../src/utils/toCamelKeys.ts"],"mappings":";KAIK,SAAS,oBACZ,UAAU,WAAW,UAAU;;KAG5B,UAAU,oBAAoB,mBAAmB,cAAc,SAChE,sBAAsB,mBACpB,SAAS,yBACJ,OAAO,UAAU,WAAW,cAC5B,QAAQ,UAAU,UACvB,IACF;;;;KAKC,UAAU,oBAAoB,oBAAoB,aAC/C,UAAU,UACd,UAAU;;;;;;YAOF,UAAU,KACpB,UAAU,oBAAoB,KAC1B,MAAM,UAAU,MAChB,sBAEK,WAAW,KAAK,mBAAmB,UAAU,KAAK,IAAI,UACrD,EAAE,SAGN;qBAgBK,cAAe,kBAAkB,GAAG,MAAI,UAAU"}

package/dist/utils/toCamelKeys.mjs

@@ -0,0 +1,18 @@
+import { isObject } from "./isObject.mjs";
+import { toCamelCase } from "./toCamelCase.mjs";
+// src/utils/toCamelKeys.ts
+const convert = (value) => {
+	if (Array.isArray(value)) return value.map(convert);
+	else if (isObject(value)) {
+		const result = {};
+		for (const [key, val] of Object.entries(value)) result[toCamelCase(key)] = convert(val);
+		return result;
+	}
+	return value;
+};
+const toCamelKeys = (o) => {
+	return convert(o);
+};
+export { toCamelKeys };
+
+//# sourceMappingURL=toCamelKeys.mjs.map

package/dist/utils/toCamelKeys.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toCamelKeys.mjs","names":[],"sources":["../../src/utils/toCamelKeys.ts"],"sourcesContent":["import { isObject } from \"./isObject.js\";\nimport { toCamelCase } from \"./toCamelCase.js\";\n\n/** Whether a one-character string is a letter (it has a case). */\ntype IsLetter<C extends string> =\n  Lowercase<C> extends Uppercase<C> ? false : true;\n\n/** {@link CamelCase} after any leading `_`: an `_` before a letter is dropped and the letter capitalised; an `_` before anything else stays. */\ntype CamelTail<S extends string> = S extends `${infer Head}_${infer Tail}`\n  ? Tail extends `${infer First}${string}`\n    ? IsLetter<First> extends true\n      ? `${Head}${CamelTail<Capitalize<Tail>>}`\n      : `${Head}_${CamelTail<Tail>}`\n    : S\n  : S;\n\n/**\n * Convert a `snake_case` string-literal type to `camelCase`, matching exactly what {@link toCamelCase} does at runtime: `poster_path` → `posterPath`, while `iso_3166_1` and `_id` are unchanged (see `toCamelCase` for why).\n */\ntype CamelCase<S extends string> = S extends `_${infer Rest}`\n  ? `_${CamelTail<Rest>}`\n  : CamelTail<S>;\n\n/**\n * Recursively camel-case the keys of an object/array type. Mirrors\n * {@link toCamelKeys}'s runtime: arrays map element-wise, plain objects remap\n * their keys, and leaf values pass through unchanged.\n */\nexport type CamelKeys<T> =\n  T extends ReadonlyArray<infer U>\n    ? Array<CamelKeys<U>>\n    : T extends object\n      ? {\n          [K in keyof T as K extends string ? CamelCase<K> : K]: CamelKeys<\n            T[K]\n          >;\n        }\n      : T;\n\nconst convert = (value: unknown): unknown => {\n  if (Array.isArray(value)) {\n    return value.map(convert);\n  } else if (isObject(value)) {\n    const result: Record<string, unknown> = {};\n    for (const [key, val] of Object.entries(value)) {\n      result[toCamelCase(key)] = convert(val);\n    }\n    return result;\n  }\n\n  return value;\n};\n\nexport const toCamelKeys = <T extends object>(o: T): CamelKeys<T> => {\n  // Recursive key remapping can't be proven at the type level.\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n  return convert(o) as CamelKeys<T>;\n};\n"],"mappings":";;;AAuCA,MAAM,WAAW,UAA4B;CAC3C,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,IAAI,OAAO;MACnB,IAAI,SAAS,KAAK,GAAG;EAC1B,MAAM,SAAkC,CAAC;EACzC,KAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,KAAK,GAC3C,OAAO,YAAY,GAAG,KAAK,QAAQ,GAAG;EAExC,OAAO;CACT;CAEA,OAAO;AACT;AAEA,MAAa,eAAiC,MAAuB;CAGnE,OAAO,QAAQ,CAAC;AAClB"}

package/dist/utils/toSnakeCase.d.mts

@@ -0,0 +1,2 @@
+export declare const toSnakeCase: (str: string) => string;
+//# sourceMappingURL=toSnakeCase.d.mts.map

package/dist/utils/toSnakeCase.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSnakeCase.d.mts","names":[],"sources":["../../src/utils/toSnakeCase.ts"],"mappings":"A,qBAAa,cAAe"}

package/dist/utils/toSnakeCase.mjs

@@ -0,0 +1,5 @@
+// src/utils/toSnakeCase.ts
+const toSnakeCase = (str) => str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`).substring(str.slice(0, 1).match(/(?<char>[A-Z])/g) ? 1 : 0);
+export { toSnakeCase };
+
+//# sourceMappingURL=toSnakeCase.mjs.map

package/dist/utils/toSnakeCase.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSnakeCase.mjs","names":[],"sources":["../../src/utils/toSnakeCase.ts"],"sourcesContent":["export const toSnakeCase = (str: string): string =>\n  str\n    .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)\n    .substring(str.slice(0, 1).match(/(?<char>[A-Z])/g) ? 1 : 0);\n"],"mappings":";AAAA,MAAa,eAAe,QAC1B,IACG,QAAQ,WAAW,WAAW,IAAI,OAAO,YAAY,GAAG,CAAC,CACzD,UAAU,IAAI,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,iBAAiB,IAAI,IAAI,CAAC"}

package/dist/utils/toSnakeKeys.d.mts

@@ -0,0 +1,21 @@
+/** The uppercase ASCII letters, for the camel→snake split. */
+type Upper = `A` | `B` | `C` | `D` | `E` | `F` | `G` | `H` | `I` | `J` | `K` | `L` | `M` | `N` | `O` | `P` | `Q` | `R` | `S` | `T` | `U` | `V` | `W` | `X` | `Y` | `Z`;
+/**
+ * Walk a `camelCase` literal, inserting `_` before each uppercase letter and
+ * lowercasing it — matching {@link toSnakeCase}'s runtime. `Started` tracks
+ * whether we've emitted any character yet, so a leading capital (e.g. `Foo`)
+ * doesn't get a leading underscore (→ `foo`, not `_foo`).
+ */
+type SnakeWalk<S extends string, Started extends boolean = false> = S extends `${infer Head}${infer Tail}` ? Head extends Upper ? `${Started extends true ? `_` : ``}${Lowercase<Head>}${SnakeWalk<Tail, true>}` : `${Head}${SnakeWalk<Tail, true>}` : S;
+/** Convert a `camelCase` string-literal type to `snake_case`. Self-contained;
+ * mirrors {@link toSnakeCase} (the only transform we apply to API keys). */
+type SnakeCase<S extends string> = SnakeWalk<S>;
+/**
+ * Recursively snake-case the keys of an object/array type. Mirrors
+ * {@link toSnakeKeys}'s runtime. The only inputs are plain nested TMDB API
+ * JSON, so no Set/tuple/options handling is needed.
+ */
+export type SnakeKeys<T> = T extends ReadonlyArray<infer U> ? Array<SnakeKeys<U>> : T extends object ? { [K in keyof T as K extends string ? SnakeCase<K> : K]: SnakeKeys<T[K]>; } : T;
+export declare const toSnakeKeys: <T extends object>(o: T) => SnakeKeys<T>;
+export {};
+//# sourceMappingURL=toSnakeKeys.d.mts.map

package/dist/utils/toSnakeKeys.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSnakeKeys.d.mts","names":[],"sources":["../../src/utils/toSnakeKeys.ts"],"mappings":";KAIK;;;;;;;KAkCA,UACH,kBACA,mCACE,mBAAmB,aAAa,SAChC,aAAa,WACR,kCAAkC,UAAU,QAAQ,UAAU,mBAC9D,OAAO,UAAU,gBACtB;;;KAIC,UAAU,oBAAoB,UAAU;;;;;;YAOjC,UAAU,KACpB,UAAU,oBAAoB,KAC1B,MAAM,UAAU,MAChB,sBAEK,WAAW,KAAK,mBAAmB,UAAU,KAAK,IAAI,UACrD,EAAE,SAGN;qBAgBK,cAAe,kBAAkB,GAAG,MAAI,UAAU"}

package/dist/utils/toSnakeKeys.mjs

@@ -0,0 +1,18 @@
+import { toSnakeCase } from "./toSnakeCase.mjs";
+import { isObject } from "./isObject.mjs";
+// src/utils/toSnakeKeys.ts
+const convert = (value) => {
+	if (Array.isArray(value)) return value.map(convert);
+	else if (isObject(value)) {
+		const result = {};
+		for (const [key, val] of Object.entries(value)) result[toSnakeCase(key)] = convert(val);
+		return result;
+	}
+	return value;
+};
+const toSnakeKeys = (o) => {
+	return convert(o);
+};
+export { toSnakeKeys };
+
+//# sourceMappingURL=toSnakeKeys.mjs.map

package/dist/utils/toSnakeKeys.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSnakeKeys.mjs","names":[],"sources":["../../src/utils/toSnakeKeys.ts"],"sourcesContent":["import { isObject } from \"./isObject.js\";\nimport { toSnakeCase } from \"./toSnakeCase.js\";\n\n/** The uppercase ASCII letters, for the camel→snake split. */\ntype Upper =\n  | `A`\n  | `B`\n  | `C`\n  | `D`\n  | `E`\n  | `F`\n  | `G`\n  | `H`\n  | `I`\n  | `J`\n  | `K`\n  | `L`\n  | `M`\n  | `N`\n  | `O`\n  | `P`\n  | `Q`\n  | `R`\n  | `S`\n  | `T`\n  | `U`\n  | `V`\n  | `W`\n  | `X`\n  | `Y`\n  | `Z`;\n\n/**\n * Walk a `camelCase` literal, inserting `_` before each uppercase letter and\n * lowercasing it — matching {@link toSnakeCase}'s runtime. `Started` tracks\n * whether we've emitted any character yet, so a leading capital (e.g. `Foo`)\n * doesn't get a leading underscore (→ `foo`, not `_foo`).\n */\ntype SnakeWalk<\n  S extends string,\n  Started extends boolean = false\n> = S extends `${infer Head}${infer Tail}`\n  ? Head extends Upper\n    ? `${Started extends true ? `_` : ``}${Lowercase<Head>}${SnakeWalk<Tail, true>}`\n    : `${Head}${SnakeWalk<Tail, true>}`\n  : S;\n\n/** Convert a `camelCase` string-literal type to `snake_case`. Self-contained;\n * mirrors {@link toSnakeCase} (the only transform we apply to API keys). */\ntype SnakeCase<S extends string> = SnakeWalk<S>;\n\n/**\n * Recursively snake-case the keys of an object/array type. Mirrors\n * {@link toSnakeKeys}'s runtime. The only inputs are plain nested TMDB API\n * JSON, so no Set/tuple/options handling is needed.\n */\nexport type SnakeKeys<T> =\n  T extends ReadonlyArray<infer U>\n    ? Array<SnakeKeys<U>>\n    : T extends object\n      ? {\n          [K in keyof T as K extends string ? SnakeCase<K> : K]: SnakeKeys<\n            T[K]\n          >;\n        }\n      : T;\n\nconst convert = (value: unknown): unknown => {\n  if (Array.isArray(value)) {\n    return value.map(convert);\n  } else if (isObject(value)) {\n    const result: Record<string, unknown> = {};\n    for (const [key, val] of Object.entries(value)) {\n      result[toSnakeCase(key)] = convert(val);\n    }\n    return result;\n  }\n\n  return value;\n};\n\nexport const toSnakeKeys = <T extends object>(o: T): SnakeKeys<T> => {\n  // Recursive key remapping can't be proven at the type level.\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n  return convert(o) as SnakeKeys<T>;\n};\n"],"mappings":";;;AAmEA,MAAM,WAAW,UAA4B;CAC3C,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,IAAI,OAAO;MACnB,IAAI,SAAS,KAAK,GAAG;EAC1B,MAAM,SAAkC,CAAC;EACzC,KAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,KAAK,GAC3C,OAAO,YAAY,GAAG,KAAK,QAAQ,GAAG;EAExC,OAAO;CACT;CAEA,OAAO;AACT;AAEA,MAAa,eAAiC,MAAuB;CAGnE,OAAO,QAAQ,CAAC;AAClB"}

package/dist/validations/index.d.mts

@@ -0,0 +1,4 @@
+import { integer, ordinal, tmdbId } from "./integer.mjs";
+import { isoDate } from "./isoDate.mjs";
+import { omitFields, partialSchema, pickFields, requiredFields, schema, variantSchema } from "./schema.mjs";
+export { integer, isoDate, omitFields, ordinal, partialSchema, pickFields, requiredFields, schema, tmdbId, variantSchema };

package/dist/validations/index.mjs

@@ -0,0 +1,4 @@
+import { omitFields, partialSchema, pickFields, requiredFields, schema, variantSchema } from "./schema.mjs";
+import { integer, ordinal, tmdbId } from "./integer.mjs";
+import { isoDate } from "./isoDate.mjs";
+export { integer, isoDate, omitFields, ordinal, partialSchema, pickFields, requiredFields, schema, tmdbId, variantSchema };

package/dist/validations/integer.d.mts

@@ -0,0 +1,8 @@
+import * as v from "valibot";
+/** A whole number. TMDB's ids, counts, sizes and ordinals are integers on the wire; validating that also keeps generated mocks realistic. */
+export declare const integer: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
+/** A TMDB numeric id: a positive integer. */
+export declare const tmdbId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+/** A season or episode number. Season `0` holds a show's specials. */
+export declare const ordinal: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+//# sourceMappingURL=integer.d.mts.map

package/dist/validations/integer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer.d.mts","names":[],"sources":["../../src/validations/integer.ts"],"mappings":";;qBAGa,SAAO,EAAA,yBAAA,EAAA,yBAAA,EAAA;;qBAGP,QAAM,EAAA,yBAAA,EAAA,yBAAA,EAAA,kCAAA,EAAA;;qBAGN,SAAO,EAAA,yBAAA,EAAA,yBAAA,EAAA,kCAAA,EAAA"}

package/dist/validations/integer.mjs

@@ -0,0 +1,11 @@
+import * as v from "valibot";
+// src/validations/integer.ts
+/** A whole number. TMDB's ids, counts, sizes and ordinals are integers on the wire; validating that also keeps generated mocks realistic. */
+const integer = v.pipe(v.number(), v.integer());
+/** A TMDB numeric id: a positive integer. */
+const tmdbId = v.pipe(v.number(), v.integer(), v.minValue(1));
+/** A season or episode number. Season `0` holds a show's specials. */
+const ordinal = v.pipe(v.number(), v.integer(), v.minValue(0));
+export { integer, ordinal, tmdbId };
+
+//# sourceMappingURL=integer.mjs.map

package/dist/validations/integer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer.mjs","names":[],"sources":["../../src/validations/integer.ts"],"sourcesContent":["import * as v from \"valibot\";\n\n/** A whole number. TMDB's ids, counts, sizes and ordinals are integers on the wire; validating that also keeps generated mocks realistic. */\nexport const integer = v.pipe(v.number(), v.integer());\n\n/** A TMDB numeric id: a positive integer. */\nexport const tmdbId = v.pipe(v.number(), v.integer(), v.minValue(1));\n\n/** A season or episode number. Season `0` holds a show's specials. */\nexport const ordinal = v.pipe(v.number(), v.integer(), v.minValue(0));\n"],"mappings":";;;AAGA,MAAa,UAAU,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC;;AAGrD,MAAa,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,QAAQ,GAAG,EAAE,SAAS,CAAC,CAAC;;AAGnE,MAAa,UAAU,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,QAAQ,GAAG,EAAE,SAAS,CAAC,CAAC"}

package/dist/validations/isoDate.d.mts

@@ -0,0 +1,4 @@
+import * as v from "valibot";
+/** A `YYYY-MM-DD` date, as TMDB's date query params expect. */
+export declare const isoDate: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+//# sourceMappingURL=isoDate.d.mts.map

package/dist/validations/isoDate.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isoDate.d.mts","names":[],"sources":["../../src/validations/isoDate.ts"],"mappings":";;qBAGa,SAAO,EAAA,yBAAA,EAAA,yBAAA,EAAA"}

package/dist/validations/isoDate.mjs

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+// src/validations/isoDate.ts
+/** A `YYYY-MM-DD` date, as TMDB's date query params expect. */
+const isoDate = v.pipe(v.string(), v.isoDate());
+export { isoDate };
+
+//# sourceMappingURL=isoDate.mjs.map

package/dist/validations/isoDate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isoDate.mjs","names":[],"sources":["../../src/validations/isoDate.ts"],"sourcesContent":["import * as v from \"valibot\";\n\n/** A `YYYY-MM-DD` date, as TMDB's date query params expect. */\nexport const isoDate = v.pipe(v.string(), v.isoDate());\n"],"mappings":";;;AAGA,MAAa,UAAU,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC"}

package/dist/validations/schema.d.mts

@@ -0,0 +1,96 @@
+import * as v from "valibot";
+/**
+ * Annotate a schema's *published* type as `v.GenericSchema<T>` so
+ * downstream `.d.ts` emit stops inlining the inner `ObjectSchema`'s
+ * entries map and instead references `T` by name. The runtime value
+ * is unchanged.
+ *
+ * Use at every type-defining schema export:
+ *
+ * ```ts
+ * const _movieSchema = v.object({...});
+ * export interface Movie extends v.InferOutput<typeof _movieSchema> {}
+ * export const movieSchema = schema<Movie>(_movieSchema);
+ * ```
+ *
+ * **Why this exists**
+ *
+ * Without annotation, `typeof movieSchema` is the full
+ * `v.ObjectSchema<{ id: v.GenericSchema<number>, ... }>` shape. Every
+ * downstream file that references `movieSchema` (SearchResult,
+ * Recommendation, …) re-inlines that entries map into its own emitted
+ * declarations. This causes:
+ *
+ *   - dramatic duplication of nested object shapes in `.d.ts` output
+ *   - slow IDE hover (tsserver expands the full shape on every
+ *     reference)
+ *   - occasional TS2502 / type-too-complex errors on deeply circular
+ *     schemas
+ *
+ * After annotation, downstream `.d.ts` files reference `Movie` by
+ * name from `./movie/types/Movie.d.mts` and never inline its body.
+ *
+ * **Trade-off**
+ *
+ * `v.partial(movieSchema)`, `v.pick(movieSchema, [...])`, `v.omit(...)`,
+ * and `movieSchema.entries.id` stop type-checking because the constraint
+ * is `GenericSchema<T>` not `ObjectSchema<...>`. Use the
+ * {@link partialSchema}, {@link pickFields}, {@link omitFields},
+ * {@link requiredFields}, and {@link variantSchema} helpers below for
+ * the common cases.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare const schema: <T>(s: v.GenericSchema) => v.GenericSchema<T>;
+/**
+ * Make every key of `T` optional, both at the type level and at
+ * runtime. Equivalent to Valibot's `v.partial`, but accepts an
+ * annotated `GenericSchema<T>` (which `v.partial` would reject because
+ * its constraint is `ObjectSchema<...>`).
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare const partialSchema: <T>(s: v.GenericSchema<T>) => v.GenericSchema<Partial<T>>;
+/**
+ * Pick a subset of fields from `T` at both type and runtime levels.
+ * Equivalent to Valibot's `v.pick`. See {@link partialSchema}.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare const pickFields: <T, K extends keyof T & string>(s: v.GenericSchema<T>, keys: readonly K[]) => v.GenericSchema<Pick<T, K>>;
+/**
+ * Omit a subset of fields on `T` at both type and runtime levels.
+ * Equivalent to Valibot's `v.omit`. See {@link partialSchema}.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare const omitFields: <T, K extends keyof T & string>(s: v.GenericSchema<T>, keys: readonly K[]) => v.GenericSchema<Omit<T, K>>;
+/**
+ * Mark a subset of fields on `T` as required at both type and runtime
+ * levels. Equivalent to Valibot's `v.required`. See {@link partialSchema}.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare const requiredFields: <T, K extends keyof T & string>(s: v.GenericSchema<T>, keys: readonly K[]) => v.GenericSchema<T & Required<Pick<T, K>>>;
+/**
+ * Build a discriminated union schema. Equivalent to Valibot's `v.variant`,
+ * but accepts annotated `GenericSchema<T>` variants (which `v.variant`
+ * would reject because its constraint is `ObjectSchema<...>`).
+ *
+ * Prefer `v.variant` whenever variants share a literal discriminator
+ * field — it dispatches on that field at runtime, producing focused
+ * error messages and O(1) validation, vs. {@link v.union}'s O(n)
+ * try-each behavior.
+ *
+ * @example
+ * ```ts
+ * export const multiSearchResultSchema = variantSchema<MultiSearchResult>(
+ *   `mediaType`,
+ *   [movieSearchResultSchema, tvSearchResultSchema, personSearchResultSchema]
+ * );
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+export declare const variantSchema: <T>(key: keyof T & string, schemas: readonly v.GenericSchema[]) => v.GenericSchema<T>;
+//# sourceMappingURL=schema.d.mts.map

package/dist/validations/schema.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.mts","names":[],"sources":["../../src/validations/schema.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4Ca,SAAU,GAAG,GAAG,EAAE,kBAAgB,EAAE,cAAc;;;;;;;;;qBAYlD,gBAAiB,GAC5B,GAAG,EAAE,cAAc,OAClB,EAAE,cAAc,QAAQ;;;;;;;qBAgBd,aAAc,GAAG,gBAAgB,YAC5C,GAAG,EAAE,cAAc,IACnB,eAAe,QACd,EAAE,cAAc,KAAK,GAAG;;;;;;;qBAgBd,aAAc,GAAG,gBAAgB,YAC5C,GAAG,EAAE,cAAc,IACnB,eAAe,QACd,EAAE,cAAc,KAAK,GAAG;;;;;;;qBAgBd,iBAAkB,GAAG,gBAAgB,YAChD,GAAG,EAAE,cAAc,IACnB,eAAe,QACd,EAAE,cAAc,IAAI,SAAS,KAAK,GAAG;;;;;;;;;;;;;;;;;;;;;qBAgC3B,gBAAiB,GAC5B,WAAW,YACX,kBAAkB,EAAE,oBACnB,EAAE,cAAc"}