@omerikanec/api-client-demo 2.0.2 → 2.0.4

package/dist/my-dogs/my-dogs.d.ts

@@ -0,0 +1,329 @@
+import type { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import type { Dog, DogRequest, MeDogsChampionsListParams, MeDogsListParams, PaginatedDogList, PatchedDogRequest } from '../api.schemas';
+type AwaitedInput<T> = PromiseLike<T> | T;
+type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+/**
+ * API собак пользователя
+ * @summary Список моих собак
+ */
+export type meDogsListResponse200 = {
+    data: PaginatedDogList;
+    status: 200;
+};
+export type meDogsListResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meDogsListResponseSuccess = (meDogsListResponse200) & {
+    headers: Headers;
+};
+export type meDogsListResponseError = (meDogsListResponse401) & {
+    headers: Headers;
+};
+export type meDogsListResponse = (meDogsListResponseSuccess | meDogsListResponseError);
+export declare const getMeDogsListUrl: (params?: MeDogsListParams) => string;
+export declare const meDogsList: (params?: MeDogsListParams, options?: RequestInit) => Promise<meDogsListResponse>;
+export declare const getMeDogsListQueryKey: (params?: MeDogsListParams) => readonly ["/api/me/dogs/", ...MeDogsListParams[]];
+export declare const getMeDogsListQueryOptions: <TData = Awaited<ReturnType<typeof meDogsList>>, TError = void>(params?: MeDogsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meDogsList>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof meDogsList>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type MeDogsListQueryResult = NonNullable<Awaited<ReturnType<typeof meDogsList>>>;
+export type MeDogsListQueryError = void;
+/**
+ * @summary Список моих собак
+ */
+export declare function useMeDogsList<TData = Awaited<ReturnType<typeof meDogsList>>, TError = void>(params?: MeDogsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meDogsList>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * API собак пользователя
+ * @summary Добавить собаку
+ */
+export type meDogsCreateResponse201 = {
+    data: Dog;
+    status: 201;
+};
+export type meDogsCreateResponse400 = {
+    data: void;
+    status: 400;
+};
+export type meDogsCreateResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meDogsCreateResponseSuccess = (meDogsCreateResponse201) & {
+    headers: Headers;
+};
+export type meDogsCreateResponseError = (meDogsCreateResponse400 | meDogsCreateResponse401) & {
+    headers: Headers;
+};
+export type meDogsCreateResponse = (meDogsCreateResponseSuccess | meDogsCreateResponseError);
+export declare const getMeDogsCreateUrl: () => string;
+export declare const meDogsCreate: (dogRequest: DogRequest, options?: RequestInit) => Promise<meDogsCreateResponse>;
+export declare const getMeDogsCreateMutationOptions: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meDogsCreate>>, TError, {
+        data: DogRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof meDogsCreate>>, TError, {
+    data: DogRequest;
+}, TContext>;
+export type MeDogsCreateMutationResult = NonNullable<Awaited<ReturnType<typeof meDogsCreate>>>;
+export type MeDogsCreateMutationBody = DogRequest;
+export type MeDogsCreateMutationError = void;
+/**
+* @summary Добавить собаку
+*/
+export declare const useMeDogsCreate: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meDogsCreate>>, TError, {
+        data: DogRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationResult<Awaited<ReturnType<typeof meDogsCreate>>, TError, {
+    data: DogRequest;
+}, TContext>;
+/**
+* API собак пользователя
+* @summary Получить мою собаку по ID
+*/
+export type meDogsRetrieveResponse200 = {
+    data: Dog;
+    status: 200;
+};
+export type meDogsRetrieveResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meDogsRetrieveResponse404 = {
+    data: void;
+    status: 404;
+};
+export type meDogsRetrieveResponseSuccess = (meDogsRetrieveResponse200) & {
+    headers: Headers;
+};
+export type meDogsRetrieveResponseError = (meDogsRetrieveResponse401 | meDogsRetrieveResponse404) & {
+    headers: Headers;
+};
+export type meDogsRetrieveResponse = (meDogsRetrieveResponseSuccess | meDogsRetrieveResponseError);
+export declare const getMeDogsRetrieveUrl: (id: string) => string;
+export declare const meDogsRetrieve: (id: string, options?: RequestInit) => Promise<meDogsRetrieveResponse>;
+export declare const getMeDogsRetrieveQueryKey: (id: string) => readonly [`/api/me/dogs/${string}/`];
+export declare const getMeDogsRetrieveQueryOptions: <TData = Awaited<ReturnType<typeof meDogsRetrieve>>, TError = void>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meDogsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof meDogsRetrieve>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type MeDogsRetrieveQueryResult = NonNullable<Awaited<ReturnType<typeof meDogsRetrieve>>>;
+export type MeDogsRetrieveQueryError = void;
+/**
+ * @summary Получить мою собаку по ID
+ */
+export declare function useMeDogsRetrieve<TData = Awaited<ReturnType<typeof meDogsRetrieve>>, TError = void>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meDogsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * API собак пользователя
+ * @summary Обновить данные собаки
+ */
+export type meDogsUpdateResponse200 = {
+    data: Dog;
+    status: 200;
+};
+export type meDogsUpdateResponse400 = {
+    data: void;
+    status: 400;
+};
+export type meDogsUpdateResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meDogsUpdateResponse404 = {
+    data: void;
+    status: 404;
+};
+export type meDogsUpdateResponseSuccess = (meDogsUpdateResponse200) & {
+    headers: Headers;
+};
+export type meDogsUpdateResponseError = (meDogsUpdateResponse400 | meDogsUpdateResponse401 | meDogsUpdateResponse404) & {
+    headers: Headers;
+};
+export type meDogsUpdateResponse = (meDogsUpdateResponseSuccess | meDogsUpdateResponseError);
+export declare const getMeDogsUpdateUrl: (id: string) => string;
+export declare const meDogsUpdate: (id: string, dogRequest: DogRequest, options?: RequestInit) => Promise<meDogsUpdateResponse>;
+export declare const getMeDogsUpdateMutationOptions: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meDogsUpdate>>, TError, {
+        id: string;
+        data: DogRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof meDogsUpdate>>, TError, {
+    id: string;
+    data: DogRequest;
+}, TContext>;
+export type MeDogsUpdateMutationResult = NonNullable<Awaited<ReturnType<typeof meDogsUpdate>>>;
+export type MeDogsUpdateMutationBody = DogRequest;
+export type MeDogsUpdateMutationError = void;
+/**
+* @summary Обновить данные собаки
+*/
+export declare const useMeDogsUpdate: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meDogsUpdate>>, TError, {
+        id: string;
+        data: DogRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationResult<Awaited<ReturnType<typeof meDogsUpdate>>, TError, {
+    id: string;
+    data: DogRequest;
+}, TContext>;
+/**
+* API собак пользователя
+* @summary Частично обновить данные собаки
+*/
+export type meDogsPartialUpdateResponse200 = {
+    data: Dog;
+    status: 200;
+};
+export type meDogsPartialUpdateResponse400 = {
+    data: void;
+    status: 400;
+};
+export type meDogsPartialUpdateResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meDogsPartialUpdateResponse404 = {
+    data: void;
+    status: 404;
+};
+export type meDogsPartialUpdateResponseSuccess = (meDogsPartialUpdateResponse200) & {
+    headers: Headers;
+};
+export type meDogsPartialUpdateResponseError = (meDogsPartialUpdateResponse400 | meDogsPartialUpdateResponse401 | meDogsPartialUpdateResponse404) & {
+    headers: Headers;
+};
+export type meDogsPartialUpdateResponse = (meDogsPartialUpdateResponseSuccess | meDogsPartialUpdateResponseError);
+export declare const getMeDogsPartialUpdateUrl: (id: string) => string;
+export declare const meDogsPartialUpdate: (id: string, patchedDogRequest: PatchedDogRequest, options?: RequestInit) => Promise<meDogsPartialUpdateResponse>;
+export declare const getMeDogsPartialUpdateMutationOptions: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meDogsPartialUpdate>>, TError, {
+        id: string;
+        data: PatchedDogRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof meDogsPartialUpdate>>, TError, {
+    id: string;
+    data: PatchedDogRequest;
+}, TContext>;
+export type MeDogsPartialUpdateMutationResult = NonNullable<Awaited<ReturnType<typeof meDogsPartialUpdate>>>;
+export type MeDogsPartialUpdateMutationBody = PatchedDogRequest;
+export type MeDogsPartialUpdateMutationError = void;
+/**
+* @summary Частично обновить данные собаки
+*/
+export declare const useMeDogsPartialUpdate: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meDogsPartialUpdate>>, TError, {
+        id: string;
+        data: PatchedDogRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationResult<Awaited<ReturnType<typeof meDogsPartialUpdate>>, TError, {
+    id: string;
+    data: PatchedDogRequest;
+}, TContext>;
+/**
+* API собак пользователя
+* @summary Удалить собаку
+*/
+export type meDogsDestroyResponse204 = {
+    data: void;
+    status: 204;
+};
+export type meDogsDestroyResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meDogsDestroyResponse404 = {
+    data: void;
+    status: 404;
+};
+export type meDogsDestroyResponseSuccess = (meDogsDestroyResponse204) & {
+    headers: Headers;
+};
+export type meDogsDestroyResponseError = (meDogsDestroyResponse401 | meDogsDestroyResponse404) & {
+    headers: Headers;
+};
+export type meDogsDestroyResponse = (meDogsDestroyResponseSuccess | meDogsDestroyResponseError);
+export declare const getMeDogsDestroyUrl: (id: string) => string;
+export declare const meDogsDestroy: (id: string, options?: RequestInit) => Promise<meDogsDestroyResponse>;
+export declare const getMeDogsDestroyMutationOptions: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meDogsDestroy>>, TError, {
+        id: string;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof meDogsDestroy>>, TError, {
+    id: string;
+}, TContext>;
+export type MeDogsDestroyMutationResult = NonNullable<Awaited<ReturnType<typeof meDogsDestroy>>>;
+export type MeDogsDestroyMutationError = void;
+/**
+* @summary Удалить собаку
+*/
+export declare const useMeDogsDestroy: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meDogsDestroy>>, TError, {
+        id: string;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationResult<Awaited<ReturnType<typeof meDogsDestroy>>, TError, {
+    id: string;
+}, TContext>;
+/**
+* Возвращает только собак с титулом чемпиона.
+* @summary Список моих чемпионов
+*/
+export type meDogsChampionsListResponse200 = {
+    data: PaginatedDogList;
+    status: 200;
+};
+export type meDogsChampionsListResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meDogsChampionsListResponseSuccess = (meDogsChampionsListResponse200) & {
+    headers: Headers;
+};
+export type meDogsChampionsListResponseError = (meDogsChampionsListResponse401) & {
+    headers: Headers;
+};
+export type meDogsChampionsListResponse = (meDogsChampionsListResponseSuccess | meDogsChampionsListResponseError);
+export declare const getMeDogsChampionsListUrl: (params?: MeDogsChampionsListParams) => string;
+export declare const meDogsChampionsList: (params?: MeDogsChampionsListParams, options?: RequestInit) => Promise<meDogsChampionsListResponse>;
+export declare const getMeDogsChampionsListQueryKey: (params?: MeDogsChampionsListParams) => readonly ["/api/me/dogs/champions/", ...MeDogsChampionsListParams[]];
+export declare const getMeDogsChampionsListQueryOptions: <TData = Awaited<ReturnType<typeof meDogsChampionsList>>, TError = void>(params?: MeDogsChampionsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meDogsChampionsList>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof meDogsChampionsList>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type MeDogsChampionsListQueryResult = NonNullable<Awaited<ReturnType<typeof meDogsChampionsList>>>;
+export type MeDogsChampionsListQueryError = void;
+/**
+ * @summary Список моих чемпионов
+ */
+export declare function useMeDogsChampionsList<TData = Awaited<ReturnType<typeof meDogsChampionsList>>, TError = void>(params?: MeDogsChampionsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meDogsChampionsList>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};

package/dist/my-dogs/my-dogs.js

@@ -0,0 +1,245 @@
+/**
+ * Generated by orval v8.5.3 🍺
+ * Do not edit manually.
+ * НКП Сибирский Хаски API
+ * API для Национального клуба породы Сибирский хаски
+ * OpenAPI spec version: 1.0.0
+ */
+import { useMutation, useQuery } from '@tanstack/react-query';
+export const getMeDogsListUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/api/me/dogs/?${stringifiedParams}` : `/api/me/dogs/`;
+};
+export const meDogsList = async (params, options) => {
+    const res = await fetch(getMeDogsListUrl(params), {
+        ...options,
+        method: 'GET'
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getMeDogsListQueryKey = (params) => {
+    return [
+        `/api/me/dogs/`, ...(params ? [params] : [])
+    ];
+};
+export const getMeDogsListQueryOptions = (params, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getMeDogsListQueryKey(params);
+    const queryFn = ({ signal }) => meDogsList(params, { signal, ...fetchOptions });
+    return { queryKey, queryFn, ...queryOptions };
+};
+/**
+ * @summary Список моих собак
+ */
+export function useMeDogsList(params, options) {
+    const queryOptions = getMeDogsListQueryOptions(params, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+export const getMeDogsCreateUrl = () => {
+    return `/api/me/dogs/`;
+};
+export const meDogsCreate = async (dogRequest, options) => {
+    const res = await fetch(getMeDogsCreateUrl(), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(dogRequest)
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getMeDogsCreateMutationOptions = (options) => {
+    const mutationKey = ['meDogsCreate'];
+    const { mutation: mutationOptions, fetch: fetchOptions } = options ?
+        options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+            options
+            : { ...options, mutation: { ...options.mutation, mutationKey } }
+        : { mutation: { mutationKey, }, fetch: undefined };
+    const mutationFn = (props) => {
+        const { data } = props ?? {};
+        return meDogsCreate(data, fetchOptions);
+    };
+    return { mutationFn, ...mutationOptions };
+};
+/**
+* @summary Добавить собаку
+*/
+export const useMeDogsCreate = (options) => {
+    return useMutation(getMeDogsCreateMutationOptions(options));
+};
+export const getMeDogsRetrieveUrl = (id) => {
+    return `/api/me/dogs/${id}/`;
+};
+export const meDogsRetrieve = async (id, options) => {
+    const res = await fetch(getMeDogsRetrieveUrl(id), {
+        ...options,
+        method: 'GET'
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getMeDogsRetrieveQueryKey = (id) => {
+    return [
+        `/api/me/dogs/${id}/`
+    ];
+};
+export const getMeDogsRetrieveQueryOptions = (id, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getMeDogsRetrieveQueryKey(id);
+    const queryFn = ({ signal }) => meDogsRetrieve(id, { signal, ...fetchOptions });
+    return { queryKey, queryFn, enabled: !!(id), ...queryOptions };
+};
+/**
+ * @summary Получить мою собаку по ID
+ */
+export function useMeDogsRetrieve(id, options) {
+    const queryOptions = getMeDogsRetrieveQueryOptions(id, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+export const getMeDogsUpdateUrl = (id) => {
+    return `/api/me/dogs/${id}/`;
+};
+export const meDogsUpdate = async (id, dogRequest, options) => {
+    const res = await fetch(getMeDogsUpdateUrl(id), {
+        ...options,
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(dogRequest)
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getMeDogsUpdateMutationOptions = (options) => {
+    const mutationKey = ['meDogsUpdate'];
+    const { mutation: mutationOptions, fetch: fetchOptions } = options ?
+        options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+            options
+            : { ...options, mutation: { ...options.mutation, mutationKey } }
+        : { mutation: { mutationKey, }, fetch: undefined };
+    const mutationFn = (props) => {
+        const { id, data } = props ?? {};
+        return meDogsUpdate(id, data, fetchOptions);
+    };
+    return { mutationFn, ...mutationOptions };
+};
+/**
+* @summary Обновить данные собаки
+*/
+export const useMeDogsUpdate = (options) => {
+    return useMutation(getMeDogsUpdateMutationOptions(options));
+};
+export const getMeDogsPartialUpdateUrl = (id) => {
+    return `/api/me/dogs/${id}/`;
+};
+export const meDogsPartialUpdate = async (id, patchedDogRequest, options) => {
+    const res = await fetch(getMeDogsPartialUpdateUrl(id), {
+        ...options,
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(patchedDogRequest)
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getMeDogsPartialUpdateMutationOptions = (options) => {
+    const mutationKey = ['meDogsPartialUpdate'];
+    const { mutation: mutationOptions, fetch: fetchOptions } = options ?
+        options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+            options
+            : { ...options, mutation: { ...options.mutation, mutationKey } }
+        : { mutation: { mutationKey, }, fetch: undefined };
+    const mutationFn = (props) => {
+        const { id, data } = props ?? {};
+        return meDogsPartialUpdate(id, data, fetchOptions);
+    };
+    return { mutationFn, ...mutationOptions };
+};
+/**
+* @summary Частично обновить данные собаки
+*/
+export const useMeDogsPartialUpdate = (options) => {
+    return useMutation(getMeDogsPartialUpdateMutationOptions(options));
+};
+export const getMeDogsDestroyUrl = (id) => {
+    return `/api/me/dogs/${id}/`;
+};
+export const meDogsDestroy = async (id, options) => {
+    const res = await fetch(getMeDogsDestroyUrl(id), {
+        ...options,
+        method: 'DELETE'
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getMeDogsDestroyMutationOptions = (options) => {
+    const mutationKey = ['meDogsDestroy'];
+    const { mutation: mutationOptions, fetch: fetchOptions } = options ?
+        options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+            options
+            : { ...options, mutation: { ...options.mutation, mutationKey } }
+        : { mutation: { mutationKey, }, fetch: undefined };
+    const mutationFn = (props) => {
+        const { id } = props ?? {};
+        return meDogsDestroy(id, fetchOptions);
+    };
+    return { mutationFn, ...mutationOptions };
+};
+/**
+* @summary Удалить собаку
+*/
+export const useMeDogsDestroy = (options) => {
+    return useMutation(getMeDogsDestroyMutationOptions(options));
+};
+export const getMeDogsChampionsListUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/api/me/dogs/champions/?${stringifiedParams}` : `/api/me/dogs/champions/`;
+};
+export const meDogsChampionsList = async (params, options) => {
+    const res = await fetch(getMeDogsChampionsListUrl(params), {
+        ...options,
+        method: 'GET'
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getMeDogsChampionsListQueryKey = (params) => {
+    return [
+        `/api/me/dogs/champions/`, ...(params ? [params] : [])
+    ];
+};
+export const getMeDogsChampionsListQueryOptions = (params, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getMeDogsChampionsListQueryKey(params);
+    const queryFn = ({ signal }) => meDogsChampionsList(params, { signal, ...fetchOptions });
+    return { queryKey, queryFn, ...queryOptions };
+};
+/**
+ * @summary Список моих чемпионов
+ */
+export function useMeDogsChampionsList(params, options) {
+    const queryOptions = getMeDogsChampionsListQueryOptions(params, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}