@saeris/tmdbkit 0.0.0 → 0.1.0

package/dist/discover/discoverTvSeries.d.mts

@@ -0,0 +1,608 @@
+import { Fetcher } from "../requests/methods.mjs";
+import { PagedTvResults } from "../tv/types/TvListItem.mjs";
+import * as v from "valibot";
+export declare const discoverTvSeriesSchema: v.ObjectSchema<{
+  readonly params: v.ExactOptionalSchema<Omit<v.ObjectSchema<{
+    readonly firstAirDateYear: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
+    readonly includeAdult: v.BooleanSchema<undefined>;
+    readonly includeNullFirstAirDates: v.BooleanSchema<undefined>;
+    readonly language: v.StringSchema<undefined>;
+    readonly page: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
+    readonly screenedTheatrically: v.BooleanSchema<undefined>;
+    readonly sortBy: v.PicklistSchema<["first_air_date.asc", "first_air_date.desc", "name.asc", "name.desc", "original_name.asc", "original_name.desc", "popularity.asc", "popularity.desc", "vote_average.asc", "vote_average.desc", "vote_count.asc", "vote_count.desc"], undefined>;
+    readonly timezone: v.StringSchema<undefined>;
+    /** Use in conjunction with `with_watch_monetization_types ` or `with_watch_providers ` */
+    readonly watchRegion: v.StringSchema<undefined>;
+    /** Can be a comma (`AND`) or pipe (`OR`) separated query */
+    readonly withCompanies: v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.StringSchema<undefined>], undefined>, undefined>], undefined>;
+    /** Can be a comma (`AND`) or pipe (`OR`) separated query */
+    readonly withGenres: v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.StringSchema<undefined>], undefined>, undefined>], undefined>;
+    /** Can be a comma (`AND`) or pipe (`OR`) separated query */
+    readonly withKeywords: v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.StringSchema<undefined>], undefined>, undefined>], undefined>;
+    readonly withNetworks: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
+    readonly withOriginCountry: v.StringSchema<undefined>;
+    readonly withOriginalLanguage: v.StringSchema<undefined>;
+    /** Possible values are: [0, 1, 2, 3, 4, 5], can be a comma (`AND`) or pipe (`OR`) separated query */
+    readonly withStatus: v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>;
+    /** Possible values are: [flatrate, free, ads, rent, buy] use in conjunction with `watch_region`, can be a comma (`AND`) or pipe (`OR`) separated query */
+    readonly withWatchMonetizationTypes: v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>;
+    /** Use in conjunction with `watch_region`, can be a comma (`AND`) or pipe (`OR`) separated query */
+    readonly withWatchProviders: v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.StringSchema<undefined>], undefined>, undefined>], undefined>;
+    readonly withoutCompanies: v.StringSchema<undefined>;
+    readonly withoutGenres: v.StringSchema<undefined>;
+    readonly withoutKeywords: v.StringSchema<undefined>;
+    readonly withoutWatchProviders: v.StringSchema<undefined>;
+    /** Possible values are: [0, 1, 2, 3, 4, 5, 6], can be a comma (`AND`) or pipe (`OR`) separated query */
+    readonly withType: v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>;
+    readonly airDate: Omit<v.ObjectSchema<{
+      readonly gte: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+      readonly lte: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+      readonly entries: {
+        readonly gte: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>, undefined>;
+        readonly lte: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>, undefined>;
+      };
+      readonly "~standard": v.StandardProps<{
+        gte?: string | undefined;
+        lte?: string | undefined;
+      }, {
+        gte?: string | undefined;
+        lte?: string | undefined;
+      }>;
+      readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+        gte?: string | undefined;
+        lte?: string | undefined;
+      }, v.StringIssue | v.ObjectIssue | v.IsoDateIssue<string>>;
+      readonly "~types"?: {
+        readonly input: {
+          gte?: string | undefined;
+          lte?: string | undefined;
+        };
+        readonly output: {
+          gte?: string | undefined;
+          lte?: string | undefined;
+        };
+        readonly issue: v.StringIssue | v.ObjectIssue | v.IsoDateIssue<string>;
+      } | undefined;
+    };
+    readonly firstAirDate: Omit<v.ObjectSchema<{
+      readonly gte: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+      readonly lte: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+    }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+      readonly entries: {
+        readonly gte: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>, undefined>;
+        readonly lte: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>, undefined>;
+      };
+      readonly "~standard": v.StandardProps<{
+        gte?: string | undefined;
+        lte?: string | undefined;
+      }, {
+        gte?: string | undefined;
+        lte?: string | undefined;
+      }>;
+      readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+        gte?: string | undefined;
+        lte?: string | undefined;
+      }, v.StringIssue | v.ObjectIssue | v.IsoDateIssue<string>>;
+      readonly "~types"?: {
+        readonly input: {
+          gte?: string | undefined;
+          lte?: string | undefined;
+        };
+        readonly output: {
+          gte?: string | undefined;
+          lte?: string | undefined;
+        };
+        readonly issue: v.StringIssue | v.ObjectIssue | v.IsoDateIssue<string>;
+      } | undefined;
+    };
+    readonly voteAverage: Omit<v.ObjectSchema<{
+      readonly gte: v.NumberSchema<undefined>;
+      readonly lte: v.NumberSchema<undefined>;
+    }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+      readonly entries: {
+        readonly gte: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly lte: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+      };
+      readonly "~standard": v.StandardProps<{
+        gte?: number | undefined;
+        lte?: number | undefined;
+      }, {
+        gte?: number | undefined;
+        lte?: number | undefined;
+      }>;
+      readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+        gte?: number | undefined;
+        lte?: number | undefined;
+      }, v.ObjectIssue | v.NumberIssue>;
+      readonly "~types"?: {
+        readonly input: {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        };
+        readonly output: {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        };
+        readonly issue: v.ObjectIssue | v.NumberIssue;
+      } | undefined;
+    };
+    readonly voteCount: Omit<v.ObjectSchema<{
+      readonly gte: v.NumberSchema<undefined>;
+      readonly lte: v.NumberSchema<undefined>;
+    }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+      readonly entries: {
+        readonly gte: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly lte: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+      };
+      readonly "~standard": v.StandardProps<{
+        gte?: number | undefined;
+        lte?: number | undefined;
+      }, {
+        gte?: number | undefined;
+        lte?: number | undefined;
+      }>;
+      readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+        gte?: number | undefined;
+        lte?: number | undefined;
+      }, v.ObjectIssue | v.NumberIssue>;
+      readonly "~types"?: {
+        readonly input: {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        };
+        readonly output: {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        };
+        readonly issue: v.ObjectIssue | v.NumberIssue;
+      } | undefined;
+    };
+    readonly withRuntime: Omit<v.ObjectSchema<{
+      readonly gte: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
+      readonly lte: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
+    }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+      readonly entries: {
+        readonly gte: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, undefined>;
+        readonly lte: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, undefined>;
+      };
+      readonly "~standard": v.StandardProps<{
+        gte?: number | undefined;
+        lte?: number | undefined;
+      }, {
+        gte?: number | undefined;
+        lte?: number | undefined;
+      }>;
+      readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+        gte?: number | undefined;
+        lte?: number | undefined;
+      }, v.ObjectIssue | v.NumberIssue | v.IntegerIssue<number>>;
+      readonly "~types"?: {
+        readonly input: {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        };
+        readonly output: {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        };
+        readonly issue: v.ObjectIssue | v.NumberIssue | v.IntegerIssue<number>;
+      } | undefined;
+    };
+  }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+    readonly entries: {
+      readonly firstAirDateYear: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, undefined>;
+      readonly includeAdult: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+      readonly includeNullFirstAirDates: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+      readonly language: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly page: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, undefined>;
+      readonly screenedTheatrically: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+      readonly sortBy: v.OptionalSchema<v.PicklistSchema<["first_air_date.asc", "first_air_date.desc", "name.asc", "name.desc", "original_name.asc", "original_name.desc", "popularity.asc", "popularity.desc", "vote_average.asc", "vote_average.desc", "vote_count.asc", "vote_count.desc"], undefined>, undefined>;
+      readonly timezone: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly watchRegion: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly withCompanies: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.StringSchema<undefined>], undefined>, undefined>], undefined>, undefined>;
+      readonly withGenres: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.StringSchema<undefined>], undefined>, undefined>], undefined>, undefined>;
+      readonly withKeywords: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.StringSchema<undefined>], undefined>, undefined>], undefined>, undefined>;
+      readonly withNetworks: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, undefined>;
+      readonly withOriginCountry: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly withOriginalLanguage: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly withStatus: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+      readonly withWatchMonetizationTypes: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+      readonly withWatchProviders: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, v.StringSchema<undefined>], undefined>, undefined>], undefined>, undefined>;
+      readonly withoutCompanies: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly withoutGenres: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly withoutKeywords: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly withoutWatchProviders: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+      readonly withType: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, undefined>;
+      readonly airDate: v.OptionalSchema<Omit<v.ObjectSchema<{
+        readonly gte: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+        readonly lte: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+      }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+        readonly entries: {
+          readonly gte: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>, undefined>;
+          readonly lte: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>, undefined>;
+        };
+        readonly "~standard": v.StandardProps<{
+          gte?: string | undefined;
+          lte?: string | undefined;
+        }, {
+          gte?: string | undefined;
+          lte?: string | undefined;
+        }>;
+        readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+          gte?: string | undefined;
+          lte?: string | undefined;
+        }, v.StringIssue | v.ObjectIssue | v.IsoDateIssue<string>>;
+        readonly "~types"?: {
+          readonly input: {
+            gte?: string | undefined;
+            lte?: string | undefined;
+          };
+          readonly output: {
+            gte?: string | undefined;
+            lte?: string | undefined;
+          };
+          readonly issue: v.StringIssue | v.ObjectIssue | v.IsoDateIssue<string>;
+        } | undefined;
+      }, undefined>;
+      readonly firstAirDate: v.OptionalSchema<Omit<v.ObjectSchema<{
+        readonly gte: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+        readonly lte: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>;
+      }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+        readonly entries: {
+          readonly gte: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>, undefined>;
+          readonly lte: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoDateAction<string, undefined>]>, undefined>;
+        };
+        readonly "~standard": v.StandardProps<{
+          gte?: string | undefined;
+          lte?: string | undefined;
+        }, {
+          gte?: string | undefined;
+          lte?: string | undefined;
+        }>;
+        readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+          gte?: string | undefined;
+          lte?: string | undefined;
+        }, v.StringIssue | v.ObjectIssue | v.IsoDateIssue<string>>;
+        readonly "~types"?: {
+          readonly input: {
+            gte?: string | undefined;
+            lte?: string | undefined;
+          };
+          readonly output: {
+            gte?: string | undefined;
+            lte?: string | undefined;
+          };
+          readonly issue: v.StringIssue | v.ObjectIssue | v.IsoDateIssue<string>;
+        } | undefined;
+      }, undefined>;
+      readonly voteAverage: v.OptionalSchema<Omit<v.ObjectSchema<{
+        readonly gte: v.NumberSchema<undefined>;
+        readonly lte: v.NumberSchema<undefined>;
+      }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+        readonly entries: {
+          readonly gte: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+          readonly lte: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        };
+        readonly "~standard": v.StandardProps<{
+          gte?: number | undefined;
+          lte?: number | undefined;
+        }, {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        }>;
+        readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+          gte?: number | undefined;
+          lte?: number | undefined;
+        }, v.ObjectIssue | v.NumberIssue>;
+        readonly "~types"?: {
+          readonly input: {
+            gte?: number | undefined;
+            lte?: number | undefined;
+          };
+          readonly output: {
+            gte?: number | undefined;
+            lte?: number | undefined;
+          };
+          readonly issue: v.ObjectIssue | v.NumberIssue;
+        } | undefined;
+      }, undefined>;
+      readonly voteCount: v.OptionalSchema<Omit<v.ObjectSchema<{
+        readonly gte: v.NumberSchema<undefined>;
+        readonly lte: v.NumberSchema<undefined>;
+      }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+        readonly entries: {
+          readonly gte: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+          readonly lte: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        };
+        readonly "~standard": v.StandardProps<{
+          gte?: number | undefined;
+          lte?: number | undefined;
+        }, {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        }>;
+        readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+          gte?: number | undefined;
+          lte?: number | undefined;
+        }, v.ObjectIssue | v.NumberIssue>;
+        readonly "~types"?: {
+          readonly input: {
+            gte?: number | undefined;
+            lte?: number | undefined;
+          };
+          readonly output: {
+            gte?: number | undefined;
+            lte?: number | undefined;
+          };
+          readonly issue: v.ObjectIssue | v.NumberIssue;
+        } | undefined;
+      }, undefined>;
+      readonly withRuntime: v.OptionalSchema<Omit<v.ObjectSchema<{
+        readonly gte: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
+        readonly lte: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
+      }, undefined>, "~types" | "~run" | "~standard" | "entries"> & {
+        readonly entries: {
+          readonly gte: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, undefined>;
+          readonly lte: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>, undefined>;
+        };
+        readonly "~standard": v.StandardProps<{
+          gte?: number | undefined;
+          lte?: number | undefined;
+        }, {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        }>;
+        readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+          gte?: number | undefined;
+          lte?: number | undefined;
+        }, v.ObjectIssue | v.NumberIssue | v.IntegerIssue<number>>;
+        readonly "~types"?: {
+          readonly input: {
+            gte?: number | undefined;
+            lte?: number | undefined;
+          };
+          readonly output: {
+            gte?: number | undefined;
+            lte?: number | undefined;
+          };
+          readonly issue: v.ObjectIssue | v.NumberIssue | v.IntegerIssue<number>;
+        } | undefined;
+      }, undefined>;
+    };
+    readonly "~standard": v.StandardProps<{
+      firstAirDateYear?: number | undefined;
+      includeAdult?: boolean | undefined;
+      includeNullFirstAirDates?: boolean | undefined;
+      language?: string | undefined;
+      page?: number | undefined;
+      screenedTheatrically?: boolean | undefined;
+      sortBy?: "popularity.asc" | "popularity.desc" | "vote_average.asc" | "vote_average.desc" | "vote_count.asc" | "vote_count.desc" | "first_air_date.asc" | "first_air_date.desc" | "name.asc" | "name.desc" | "original_name.asc" | "original_name.desc" | undefined;
+      timezone?: string | undefined;
+      watchRegion?: string | undefined;
+      withCompanies?: string | (string | number)[] | undefined;
+      withGenres?: string | (string | number)[] | undefined;
+      withKeywords?: string | (string | number)[] | undefined;
+      withNetworks?: number | undefined;
+      withOriginCountry?: string | undefined;
+      withOriginalLanguage?: string | undefined;
+      withStatus?: string | string[] | undefined;
+      withWatchMonetizationTypes?: string | string[] | undefined;
+      withWatchProviders?: string | (string | number)[] | undefined;
+      withoutCompanies?: string | undefined;
+      withoutGenres?: string | undefined;
+      withoutKeywords?: string | undefined;
+      withoutWatchProviders?: string | undefined;
+      withType?: string | string[] | undefined;
+      airDate?: {
+        gte?: string | undefined;
+        lte?: string | undefined;
+      } | undefined;
+      firstAirDate?: {
+        gte?: string | undefined;
+        lte?: string | undefined;
+      } | undefined;
+      voteAverage?: {
+        gte?: number | undefined;
+        lte?: number | undefined;
+      } | undefined;
+      voteCount?: {
+        gte?: number | undefined;
+        lte?: number | undefined;
+      } | undefined;
+      withRuntime?: {
+        gte?: number | undefined;
+        lte?: number | undefined;
+      } | undefined;
+    }, {
+      firstAirDateYear?: number | undefined;
+      includeAdult?: boolean | undefined;
+      includeNullFirstAirDates?: boolean | undefined;
+      language?: string | undefined;
+      page?: number | undefined;
+      screenedTheatrically?: boolean | undefined;
+      sortBy?: "popularity.asc" | "popularity.desc" | "vote_average.asc" | "vote_average.desc" | "vote_count.asc" | "vote_count.desc" | "first_air_date.asc" | "first_air_date.desc" | "name.asc" | "name.desc" | "original_name.asc" | "original_name.desc" | undefined;
+      timezone?: string | undefined;
+      watchRegion?: string | undefined;
+      withCompanies?: string | (string | number)[] | undefined;
+      withGenres?: string | (string | number)[] | undefined;
+      withKeywords?: string | (string | number)[] | undefined;
+      withNetworks?: number | undefined;
+      withOriginCountry?: string | undefined;
+      withOriginalLanguage?: string | undefined;
+      withStatus?: string | string[] | undefined;
+      withWatchMonetizationTypes?: string | string[] | undefined;
+      withWatchProviders?: string | (string | number)[] | undefined;
+      withoutCompanies?: string | undefined;
+      withoutGenres?: string | undefined;
+      withoutKeywords?: string | undefined;
+      withoutWatchProviders?: string | undefined;
+      withType?: string | string[] | undefined;
+      airDate?: {
+        gte?: string | undefined;
+        lte?: string | undefined;
+      } | undefined;
+      firstAirDate?: {
+        gte?: string | undefined;
+        lte?: string | undefined;
+      } | undefined;
+      voteAverage?: {
+        gte?: number | undefined;
+        lte?: number | undefined;
+      } | undefined;
+      voteCount?: {
+        gte?: number | undefined;
+        lte?: number | undefined;
+      } | undefined;
+      withRuntime?: {
+        gte?: number | undefined;
+        lte?: number | undefined;
+      } | undefined;
+    }>;
+    readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+      firstAirDateYear?: number | undefined;
+      includeAdult?: boolean | undefined;
+      includeNullFirstAirDates?: boolean | undefined;
+      language?: string | undefined;
+      page?: number | undefined;
+      screenedTheatrically?: boolean | undefined;
+      sortBy?: "popularity.asc" | "popularity.desc" | "vote_average.asc" | "vote_average.desc" | "vote_count.asc" | "vote_count.desc" | "first_air_date.asc" | "first_air_date.desc" | "name.asc" | "name.desc" | "original_name.asc" | "original_name.desc" | undefined;
+      timezone?: string | undefined;
+      watchRegion?: string | undefined;
+      withCompanies?: string | (string | number)[] | undefined;
+      withGenres?: string | (string | number)[] | undefined;
+      withKeywords?: string | (string | number)[] | undefined;
+      withNetworks?: number | undefined;
+      withOriginCountry?: string | undefined;
+      withOriginalLanguage?: string | undefined;
+      withStatus?: string | string[] | undefined;
+      withWatchMonetizationTypes?: string | string[] | undefined;
+      withWatchProviders?: string | (string | number)[] | undefined;
+      withoutCompanies?: string | undefined;
+      withoutGenres?: string | undefined;
+      withoutKeywords?: string | undefined;
+      withoutWatchProviders?: string | undefined;
+      withType?: string | string[] | undefined;
+      airDate?: {
+        gte?: string | undefined;
+        lte?: string | undefined;
+      } | undefined;
+      firstAirDate?: {
+        gte?: string | undefined;
+        lte?: string | undefined;
+      } | undefined;
+      voteAverage?: {
+        gte?: number | undefined;
+        lte?: number | undefined;
+      } | undefined;
+      voteCount?: {
+        gte?: number | undefined;
+        lte?: number | undefined;
+      } | undefined;
+      withRuntime?: {
+        gte?: number | undefined;
+        lte?: number | undefined;
+      } | undefined;
+    }, v.StringIssue | v.ObjectIssue | v.BooleanIssue | v.NumberIssue | v.IntegerIssue<number> | v.PicklistIssue | v.ArrayIssue | v.UnionIssue<v.StringIssue | v.NumberIssue | v.IntegerIssue<number>> | v.UnionIssue<v.StringIssue | v.NumberIssue | v.IntegerIssue<number> | v.ArrayIssue | v.UnionIssue<v.StringIssue | v.NumberIssue | v.IntegerIssue<number>>> | v.UnionIssue<v.StringIssue | v.ArrayIssue> | v.IsoDateIssue<string>>;
+    readonly "~types"?: {
+      readonly input: {
+        firstAirDateYear?: number | undefined;
+        includeAdult?: boolean | undefined;
+        includeNullFirstAirDates?: boolean | undefined;
+        language?: string | undefined;
+        page?: number | undefined;
+        screenedTheatrically?: boolean | undefined;
+        sortBy?: "popularity.asc" | "popularity.desc" | "vote_average.asc" | "vote_average.desc" | "vote_count.asc" | "vote_count.desc" | "first_air_date.asc" | "first_air_date.desc" | "name.asc" | "name.desc" | "original_name.asc" | "original_name.desc" | undefined;
+        timezone?: string | undefined;
+        watchRegion?: string | undefined;
+        withCompanies?: string | (string | number)[] | undefined;
+        withGenres?: string | (string | number)[] | undefined;
+        withKeywords?: string | (string | number)[] | undefined;
+        withNetworks?: number | undefined;
+        withOriginCountry?: string | undefined;
+        withOriginalLanguage?: string | undefined;
+        withStatus?: string | string[] | undefined;
+        withWatchMonetizationTypes?: string | string[] | undefined;
+        withWatchProviders?: string | (string | number)[] | undefined;
+        withoutCompanies?: string | undefined;
+        withoutGenres?: string | undefined;
+        withoutKeywords?: string | undefined;
+        withoutWatchProviders?: string | undefined;
+        withType?: string | string[] | undefined;
+        airDate?: {
+          gte?: string | undefined;
+          lte?: string | undefined;
+        } | undefined;
+        firstAirDate?: {
+          gte?: string | undefined;
+          lte?: string | undefined;
+        } | undefined;
+        voteAverage?: {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        } | undefined;
+        voteCount?: {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        } | undefined;
+        withRuntime?: {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        } | undefined;
+      };
+      readonly output: {
+        firstAirDateYear?: number | undefined;
+        includeAdult?: boolean | undefined;
+        includeNullFirstAirDates?: boolean | undefined;
+        language?: string | undefined;
+        page?: number | undefined;
+        screenedTheatrically?: boolean | undefined;
+        sortBy?: "popularity.asc" | "popularity.desc" | "vote_average.asc" | "vote_average.desc" | "vote_count.asc" | "vote_count.desc" | "first_air_date.asc" | "first_air_date.desc" | "name.asc" | "name.desc" | "original_name.asc" | "original_name.desc" | undefined;
+        timezone?: string | undefined;
+        watchRegion?: string | undefined;
+        withCompanies?: string | (string | number)[] | undefined;
+        withGenres?: string | (string | number)[] | undefined;
+        withKeywords?: string | (string | number)[] | undefined;
+        withNetworks?: number | undefined;
+        withOriginCountry?: string | undefined;
+        withOriginalLanguage?: string | undefined;
+        withStatus?: string | string[] | undefined;
+        withWatchMonetizationTypes?: string | string[] | undefined;
+        withWatchProviders?: string | (string | number)[] | undefined;
+        withoutCompanies?: string | undefined;
+        withoutGenres?: string | undefined;
+        withoutKeywords?: string | undefined;
+        withoutWatchProviders?: string | undefined;
+        withType?: string | string[] | undefined;
+        airDate?: {
+          gte?: string | undefined;
+          lte?: string | undefined;
+        } | undefined;
+        firstAirDate?: {
+          gte?: string | undefined;
+          lte?: string | undefined;
+        } | undefined;
+        voteAverage?: {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        } | undefined;
+        voteCount?: {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        } | undefined;
+        withRuntime?: {
+          gte?: number | undefined;
+          lte?: number | undefined;
+        } | undefined;
+      };
+      readonly issue: v.StringIssue | v.ObjectIssue | v.BooleanIssue | v.NumberIssue | v.IntegerIssue<number> | v.PicklistIssue | v.ArrayIssue | v.UnionIssue<v.StringIssue | v.NumberIssue | v.IntegerIssue<number>> | v.UnionIssue<v.StringIssue | v.NumberIssue | v.IntegerIssue<number> | v.ArrayIssue | v.UnionIssue<v.StringIssue | v.NumberIssue | v.IntegerIssue<number>>> | v.UnionIssue<v.StringIssue | v.ArrayIssue> | v.IsoDateIssue<string>;
+    } | undefined;
+  }, undefined>;
+}, undefined>;
+/**
+ * ### [TV](https://developer.themoviedb.org/reference/discover-tv)
+ *
+ * **GET** `/discover/tv`
+ */
+export declare const discoverTvSeries: Fetcher<typeof discoverTvSeriesSchema, PagedTvResults>;
+//# sourceMappingURL=discoverTvSeries.d.mts.map

package/dist/discover/discoverTvSeries.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discoverTvSeries.d.mts","names":[],"sources":["../../src/discover/discoverTvSeries.ts"],"mappings":";;;qBAMa,wBAAsB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoGtB,kBAAkB,eACtB,wBACP"}