@omerikanec/api-client-demo 2.0.3 → 2.0.4

package/dist/dogs/dogs.d.ts

@@ -0,0 +1,351 @@
+import type { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import type { CalculateCoiRequestRequest, CalculateCoiResponse, DogDetail, DogStatsResponse, DogsListParams, DogsOffspringListParams, DogsPedigreeRetrieveParams, DogsSearchListParams, DogsSiblingsListParams, PaginatedDogListList, Pedigree, RecalculateAllCoiRequestRequest, TaskResponse } from '../api.schemas';
+type AwaitedInput<T> = PromiseLike<T> | T;
+type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+/**
+ * Возвращает пагинированный список собак. Поддерживает поиск и фильтрацию.
+ * @summary Список собак
+ */
+export type dogsListResponse200 = {
+    data: PaginatedDogListList;
+    status: 200;
+};
+export type dogsListResponseSuccess = (dogsListResponse200) & {
+    headers: Headers;
+};
+export type dogsListResponse = (dogsListResponseSuccess);
+export declare const getDogsListUrl: (params?: DogsListParams) => string;
+export declare const dogsList: (params?: DogsListParams, options?: RequestInit) => Promise<dogsListResponse>;
+export declare const getDogsListQueryKey: (params?: DogsListParams) => readonly ["/api/dogs/", ...DogsListParams[]];
+export declare const getDogsListQueryOptions: <TData = Awaited<ReturnType<typeof dogsList>>, TError = unknown>(params?: DogsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsList>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof dogsList>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type DogsListQueryResult = NonNullable<Awaited<ReturnType<typeof dogsList>>>;
+export type DogsListQueryError = unknown;
+/**
+ * @summary Список собак
+ */
+export declare function useDogsList<TData = Awaited<ReturnType<typeof dogsList>>, TError = unknown>(params?: DogsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsList>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Возвращает полную информацию о собаке, включая родителей, заводчиков, титулы и медицинские записи.
+ * @summary Детальная информация о собаке
+ */
+export type dogsRetrieveResponse200 = {
+    data: DogDetail;
+    status: 200;
+};
+export type dogsRetrieveResponse404 = {
+    data: void;
+    status: 404;
+};
+export type dogsRetrieveResponseSuccess = (dogsRetrieveResponse200) & {
+    headers: Headers;
+};
+export type dogsRetrieveResponseError = (dogsRetrieveResponse404) & {
+    headers: Headers;
+};
+export type dogsRetrieveResponse = (dogsRetrieveResponseSuccess | dogsRetrieveResponseError);
+export declare const getDogsRetrieveUrl: (id: number) => string;
+export declare const dogsRetrieve: (id: number, options?: RequestInit) => Promise<dogsRetrieveResponse>;
+export declare const getDogsRetrieveQueryKey: (id: number) => readonly [`/api/dogs/${number}/`];
+export declare const getDogsRetrieveQueryOptions: <TData = Awaited<ReturnType<typeof dogsRetrieve>>, TError = void>(id: number, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof dogsRetrieve>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type DogsRetrieveQueryResult = NonNullable<Awaited<ReturnType<typeof dogsRetrieve>>>;
+export type DogsRetrieveQueryError = void;
+/**
+ * @summary Детальная информация о собаке
+ */
+export declare function useDogsRetrieve<TData = Awaited<ReturnType<typeof dogsRetrieve>>, TError = void>(id: number, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Рассчитывает и сохраняет коэффициент инбридинга (COI) для указанной собаки. Глубина расчёта от 1 до 10 поколений.
+ * @summary Рассчитать COI для собаки
+ */
+export type dogsCalculateCoiCreateResponse200 = {
+    data: CalculateCoiResponse;
+    status: 200;
+};
+export type dogsCalculateCoiCreateResponse404 = {
+    data: void;
+    status: 404;
+};
+export type dogsCalculateCoiCreateResponse422 = {
+    data: void;
+    status: 422;
+};
+export type dogsCalculateCoiCreateResponseSuccess = (dogsCalculateCoiCreateResponse200) & {
+    headers: Headers;
+};
+export type dogsCalculateCoiCreateResponseError = (dogsCalculateCoiCreateResponse404 | dogsCalculateCoiCreateResponse422) & {
+    headers: Headers;
+};
+export type dogsCalculateCoiCreateResponse = (dogsCalculateCoiCreateResponseSuccess | dogsCalculateCoiCreateResponseError);
+export declare const getDogsCalculateCoiCreateUrl: (id: number) => string;
+export declare const dogsCalculateCoiCreate: (id: number, calculateCoiRequestRequest: CalculateCoiRequestRequest, options?: RequestInit) => Promise<dogsCalculateCoiCreateResponse>;
+export declare const getDogsCalculateCoiCreateMutationOptions: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof dogsCalculateCoiCreate>>, TError, {
+        id: number;
+        data: CalculateCoiRequestRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof dogsCalculateCoiCreate>>, TError, {
+    id: number;
+    data: CalculateCoiRequestRequest;
+}, TContext>;
+export type DogsCalculateCoiCreateMutationResult = NonNullable<Awaited<ReturnType<typeof dogsCalculateCoiCreate>>>;
+export type DogsCalculateCoiCreateMutationBody = CalculateCoiRequestRequest;
+export type DogsCalculateCoiCreateMutationError = void;
+/**
+* @summary Рассчитать COI для собаки
+*/
+export declare const useDogsCalculateCoiCreate: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof dogsCalculateCoiCreate>>, TError, {
+        id: number;
+        data: CalculateCoiRequestRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationResult<Awaited<ReturnType<typeof dogsCalculateCoiCreate>>, TError, {
+    id: number;
+    data: CalculateCoiRequestRequest;
+}, TContext>;
+/**
+* Возвращает всех потомков собаки (щенков, для которых она является отцом или матерью).
+* @summary Потомки собаки
+*/
+export type dogsOffspringListResponse200 = {
+    data: PaginatedDogListList;
+    status: 200;
+};
+export type dogsOffspringListResponse404 = {
+    data: void;
+    status: 404;
+};
+export type dogsOffspringListResponseSuccess = (dogsOffspringListResponse200) & {
+    headers: Headers;
+};
+export type dogsOffspringListResponseError = (dogsOffspringListResponse404) & {
+    headers: Headers;
+};
+export type dogsOffspringListResponse = (dogsOffspringListResponseSuccess | dogsOffspringListResponseError);
+export declare const getDogsOffspringListUrl: (id: number, params?: DogsOffspringListParams) => string;
+export declare const dogsOffspringList: (id: number, params?: DogsOffspringListParams, options?: RequestInit) => Promise<dogsOffspringListResponse>;
+export declare const getDogsOffspringListQueryKey: (id: number, params?: DogsOffspringListParams) => readonly [`/api/dogs/${number}/offspring/`, ...DogsOffspringListParams[]];
+export declare const getDogsOffspringListQueryOptions: <TData = Awaited<ReturnType<typeof dogsOffspringList>>, TError = void>(id: number, params?: DogsOffspringListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsOffspringList>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof dogsOffspringList>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type DogsOffspringListQueryResult = NonNullable<Awaited<ReturnType<typeof dogsOffspringList>>>;
+export type DogsOffspringListQueryError = void;
+/**
+ * @summary Потомки собаки
+ */
+export declare function useDogsOffspringList<TData = Awaited<ReturnType<typeof dogsOffspringList>>, TError = void>(id: number, params?: DogsOffspringListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsOffspringList>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Возвращает рекурсивное дерево предков до указанной глубины (1–10 поколений).
+ * @summary Родословная собаки
+ */
+export type dogsPedigreeRetrieveResponse200 = {
+    data: Pedigree;
+    status: 200;
+};
+export type dogsPedigreeRetrieveResponse404 = {
+    data: void;
+    status: 404;
+};
+export type dogsPedigreeRetrieveResponseSuccess = (dogsPedigreeRetrieveResponse200) & {
+    headers: Headers;
+};
+export type dogsPedigreeRetrieveResponseError = (dogsPedigreeRetrieveResponse404) & {
+    headers: Headers;
+};
+export type dogsPedigreeRetrieveResponse = (dogsPedigreeRetrieveResponseSuccess | dogsPedigreeRetrieveResponseError);
+export declare const getDogsPedigreeRetrieveUrl: (id: number, params?: DogsPedigreeRetrieveParams) => string;
+export declare const dogsPedigreeRetrieve: (id: number, params?: DogsPedigreeRetrieveParams, options?: RequestInit) => Promise<dogsPedigreeRetrieveResponse>;
+export declare const getDogsPedigreeRetrieveQueryKey: (id: number, params?: DogsPedigreeRetrieveParams) => readonly [`/api/dogs/${number}/pedigree/`, ...DogsPedigreeRetrieveParams[]];
+export declare const getDogsPedigreeRetrieveQueryOptions: <TData = Awaited<ReturnType<typeof dogsPedigreeRetrieve>>, TError = void>(id: number, params?: DogsPedigreeRetrieveParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsPedigreeRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof dogsPedigreeRetrieve>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type DogsPedigreeRetrieveQueryResult = NonNullable<Awaited<ReturnType<typeof dogsPedigreeRetrieve>>>;
+export type DogsPedigreeRetrieveQueryError = void;
+/**
+ * @summary Родословная собаки
+ */
+export declare function useDogsPedigreeRetrieve<TData = Awaited<ReturnType<typeof dogsPedigreeRetrieve>>, TError = void>(id: number, params?: DogsPedigreeRetrieveParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsPedigreeRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Возвращает братьев и сестёр (однопомётников) собаки.
+ * @summary Сиблинги собаки
+ */
+export type dogsSiblingsListResponse200 = {
+    data: PaginatedDogListList;
+    status: 200;
+};
+export type dogsSiblingsListResponse404 = {
+    data: void;
+    status: 404;
+};
+export type dogsSiblingsListResponseSuccess = (dogsSiblingsListResponse200) & {
+    headers: Headers;
+};
+export type dogsSiblingsListResponseError = (dogsSiblingsListResponse404) & {
+    headers: Headers;
+};
+export type dogsSiblingsListResponse = (dogsSiblingsListResponseSuccess | dogsSiblingsListResponseError);
+export declare const getDogsSiblingsListUrl: (id: number, params?: DogsSiblingsListParams) => string;
+export declare const dogsSiblingsList: (id: number, params?: DogsSiblingsListParams, options?: RequestInit) => Promise<dogsSiblingsListResponse>;
+export declare const getDogsSiblingsListQueryKey: (id: number, params?: DogsSiblingsListParams) => readonly [`/api/dogs/${number}/siblings/`, ...DogsSiblingsListParams[]];
+export declare const getDogsSiblingsListQueryOptions: <TData = Awaited<ReturnType<typeof dogsSiblingsList>>, TError = void>(id: number, params?: DogsSiblingsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsSiblingsList>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof dogsSiblingsList>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type DogsSiblingsListQueryResult = NonNullable<Awaited<ReturnType<typeof dogsSiblingsList>>>;
+export type DogsSiblingsListQueryError = void;
+/**
+ * @summary Сиблинги собаки
+ */
+export declare function useDogsSiblingsList<TData = Awaited<ReturnType<typeof dogsSiblingsList>>, TError = void>(id: number, params?: DogsSiblingsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsSiblingsList>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Запускает Celery-задачу для пересчёта коэффициента инбридинга (COI) для всех собак в базе. Прогресс можно отслеживать через GET /api/dogs/import/status/{task_id}/.
+ * @summary Массовый пересчёт COI
+ */
+export type dogsCoiRecalculateCreateResponse202 = {
+    data: TaskResponse;
+    status: 202;
+};
+export type dogsCoiRecalculateCreateResponseSuccess = (dogsCoiRecalculateCreateResponse202) & {
+    headers: Headers;
+};
+export type dogsCoiRecalculateCreateResponse = (dogsCoiRecalculateCreateResponseSuccess);
+export declare const getDogsCoiRecalculateCreateUrl: () => string;
+export declare const dogsCoiRecalculateCreate: (recalculateAllCoiRequestRequest: RecalculateAllCoiRequestRequest, options?: RequestInit) => Promise<dogsCoiRecalculateCreateResponse>;
+export declare const getDogsCoiRecalculateCreateMutationOptions: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof dogsCoiRecalculateCreate>>, TError, {
+        data: RecalculateAllCoiRequestRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof dogsCoiRecalculateCreate>>, TError, {
+    data: RecalculateAllCoiRequestRequest;
+}, TContext>;
+export type DogsCoiRecalculateCreateMutationResult = NonNullable<Awaited<ReturnType<typeof dogsCoiRecalculateCreate>>>;
+export type DogsCoiRecalculateCreateMutationBody = RecalculateAllCoiRequestRequest;
+export type DogsCoiRecalculateCreateMutationError = unknown;
+/**
+* @summary Массовый пересчёт COI
+*/
+export declare const useDogsCoiRecalculateCreate: <TError = unknown, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof dogsCoiRecalculateCreate>>, TError, {
+        data: RecalculateAllCoiRequestRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationResult<Awaited<ReturnType<typeof dogsCoiRecalculateCreate>>, TError, {
+    data: RecalculateAllCoiRequestRequest;
+}, TContext>;
+/**
+* Возвращает до 20 собак, кличка которых содержит строку поиска.
+* @summary Поиск собак по кличке
+*/
+export type dogsSearchListResponse200 = {
+    data: PaginatedDogListList;
+    status: 200;
+};
+export type dogsSearchListResponse400 = {
+    data: void;
+    status: 400;
+};
+export type dogsSearchListResponseSuccess = (dogsSearchListResponse200) & {
+    headers: Headers;
+};
+export type dogsSearchListResponseError = (dogsSearchListResponse400) & {
+    headers: Headers;
+};
+export type dogsSearchListResponse = (dogsSearchListResponseSuccess | dogsSearchListResponseError);
+export declare const getDogsSearchListUrl: (params: DogsSearchListParams) => string;
+export declare const dogsSearchList: (params: DogsSearchListParams, options?: RequestInit) => Promise<dogsSearchListResponse>;
+export declare const getDogsSearchListQueryKey: (params?: DogsSearchListParams) => readonly ["/api/dogs/search/", ...DogsSearchListParams[]];
+export declare const getDogsSearchListQueryOptions: <TData = Awaited<ReturnType<typeof dogsSearchList>>, TError = void>(params: DogsSearchListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsSearchList>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof dogsSearchList>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type DogsSearchListQueryResult = NonNullable<Awaited<ReturnType<typeof dogsSearchList>>>;
+export type DogsSearchListQueryError = void;
+/**
+ * @summary Поиск собак по кличке
+ */
+export declare function useDogsSearchList<TData = Awaited<ReturnType<typeof dogsSearchList>>, TError = void>(params: DogsSearchListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsSearchList>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Возвращает общую статистику: количество собак, кобелей, сук, заводчиков и т.д.
+ * @summary Статистика по базе собак
+ */
+export type dogsStatsRetrieveResponse200 = {
+    data: DogStatsResponse;
+    status: 200;
+};
+export type dogsStatsRetrieveResponseSuccess = (dogsStatsRetrieveResponse200) & {
+    headers: Headers;
+};
+export type dogsStatsRetrieveResponse = (dogsStatsRetrieveResponseSuccess);
+export declare const getDogsStatsRetrieveUrl: () => string;
+export declare const dogsStatsRetrieve: (options?: RequestInit) => Promise<dogsStatsRetrieveResponse>;
+export declare const getDogsStatsRetrieveQueryKey: () => readonly ["/api/dogs/stats/"];
+export declare const getDogsStatsRetrieveQueryOptions: <TData = Awaited<ReturnType<typeof dogsStatsRetrieve>>, TError = unknown>(options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsStatsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof dogsStatsRetrieve>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type DogsStatsRetrieveQueryResult = NonNullable<Awaited<ReturnType<typeof dogsStatsRetrieve>>>;
+export type DogsStatsRetrieveQueryError = unknown;
+/**
+ * @summary Статистика по базе собак
+ */
+export declare function useDogsStatsRetrieve<TData = Awaited<ReturnType<typeof dogsStatsRetrieve>>, TError = unknown>(options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof dogsStatsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};

package/dist/dogs/dogs.js

@@ -0,0 +1,329 @@
+/**
+ * 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 getDogsListUrl = (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/dogs/?${stringifiedParams}` : `/api/dogs/`;
+};
+export const dogsList = async (params, options) => {
+    const res = await fetch(getDogsListUrl(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 getDogsListQueryKey = (params) => {
+    return [
+        `/api/dogs/`, ...(params ? [params] : [])
+    ];
+};
+export const getDogsListQueryOptions = (params, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getDogsListQueryKey(params);
+    const queryFn = ({ signal }) => dogsList(params, { signal, ...fetchOptions });
+    return { queryKey, queryFn, ...queryOptions };
+};
+/**
+ * @summary Список собак
+ */
+export function useDogsList(params, options) {
+    const queryOptions = getDogsListQueryOptions(params, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+export const getDogsRetrieveUrl = (id) => {
+    return `/api/dogs/${id}/`;
+};
+export const dogsRetrieve = async (id, options) => {
+    const res = await fetch(getDogsRetrieveUrl(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 getDogsRetrieveQueryKey = (id) => {
+    return [
+        `/api/dogs/${id}/`
+    ];
+};
+export const getDogsRetrieveQueryOptions = (id, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getDogsRetrieveQueryKey(id);
+    const queryFn = ({ signal }) => dogsRetrieve(id, { signal, ...fetchOptions });
+    return { queryKey, queryFn, enabled: !!(id), ...queryOptions };
+};
+/**
+ * @summary Детальная информация о собаке
+ */
+export function useDogsRetrieve(id, options) {
+    const queryOptions = getDogsRetrieveQueryOptions(id, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+export const getDogsCalculateCoiCreateUrl = (id) => {
+    return `/api/dogs/${id}/calculate_coi/`;
+};
+export const dogsCalculateCoiCreate = async (id, calculateCoiRequestRequest, options) => {
+    const res = await fetch(getDogsCalculateCoiCreateUrl(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(calculateCoiRequestRequest)
+    });
+    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 getDogsCalculateCoiCreateMutationOptions = (options) => {
+    const mutationKey = ['dogsCalculateCoiCreate'];
+    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 dogsCalculateCoiCreate(id, data, fetchOptions);
+    };
+    return { mutationFn, ...mutationOptions };
+};
+/**
+* @summary Рассчитать COI для собаки
+*/
+export const useDogsCalculateCoiCreate = (options) => {
+    return useMutation(getDogsCalculateCoiCreateMutationOptions(options));
+};
+export const getDogsOffspringListUrl = (id, 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/dogs/${id}/offspring/?${stringifiedParams}` : `/api/dogs/${id}/offspring/`;
+};
+export const dogsOffspringList = async (id, params, options) => {
+    const res = await fetch(getDogsOffspringListUrl(id, 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 getDogsOffspringListQueryKey = (id, params) => {
+    return [
+        `/api/dogs/${id}/offspring/`, ...(params ? [params] : [])
+    ];
+};
+export const getDogsOffspringListQueryOptions = (id, params, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getDogsOffspringListQueryKey(id, params);
+    const queryFn = ({ signal }) => dogsOffspringList(id, params, { signal, ...fetchOptions });
+    return { queryKey, queryFn, enabled: !!(id), ...queryOptions };
+};
+/**
+ * @summary Потомки собаки
+ */
+export function useDogsOffspringList(id, params, options) {
+    const queryOptions = getDogsOffspringListQueryOptions(id, params, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+export const getDogsPedigreeRetrieveUrl = (id, 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/dogs/${id}/pedigree/?${stringifiedParams}` : `/api/dogs/${id}/pedigree/`;
+};
+export const dogsPedigreeRetrieve = async (id, params, options) => {
+    const res = await fetch(getDogsPedigreeRetrieveUrl(id, 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 getDogsPedigreeRetrieveQueryKey = (id, params) => {
+    return [
+        `/api/dogs/${id}/pedigree/`, ...(params ? [params] : [])
+    ];
+};
+export const getDogsPedigreeRetrieveQueryOptions = (id, params, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getDogsPedigreeRetrieveQueryKey(id, params);
+    const queryFn = ({ signal }) => dogsPedigreeRetrieve(id, params, { signal, ...fetchOptions });
+    return { queryKey, queryFn, enabled: !!(id), ...queryOptions };
+};
+/**
+ * @summary Родословная собаки
+ */
+export function useDogsPedigreeRetrieve(id, params, options) {
+    const queryOptions = getDogsPedigreeRetrieveQueryOptions(id, params, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+export const getDogsSiblingsListUrl = (id, 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/dogs/${id}/siblings/?${stringifiedParams}` : `/api/dogs/${id}/siblings/`;
+};
+export const dogsSiblingsList = async (id, params, options) => {
+    const res = await fetch(getDogsSiblingsListUrl(id, 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 getDogsSiblingsListQueryKey = (id, params) => {
+    return [
+        `/api/dogs/${id}/siblings/`, ...(params ? [params] : [])
+    ];
+};
+export const getDogsSiblingsListQueryOptions = (id, params, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getDogsSiblingsListQueryKey(id, params);
+    const queryFn = ({ signal }) => dogsSiblingsList(id, params, { signal, ...fetchOptions });
+    return { queryKey, queryFn, enabled: !!(id), ...queryOptions };
+};
+/**
+ * @summary Сиблинги собаки
+ */
+export function useDogsSiblingsList(id, params, options) {
+    const queryOptions = getDogsSiblingsListQueryOptions(id, params, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+;
+export const getDogsCoiRecalculateCreateUrl = () => {
+    return `/api/dogs/coi/recalculate/`;
+};
+export const dogsCoiRecalculateCreate = async (recalculateAllCoiRequestRequest, options) => {
+    const res = await fetch(getDogsCoiRecalculateCreateUrl(), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(recalculateAllCoiRequestRequest)
+    });
+    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 getDogsCoiRecalculateCreateMutationOptions = (options) => {
+    const mutationKey = ['dogsCoiRecalculateCreate'];
+    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 dogsCoiRecalculateCreate(data, fetchOptions);
+    };
+    return { mutationFn, ...mutationOptions };
+};
+/**
+* @summary Массовый пересчёт COI
+*/
+export const useDogsCoiRecalculateCreate = (options) => {
+    return useMutation(getDogsCoiRecalculateCreateMutationOptions(options));
+};
+export const getDogsSearchListUrl = (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/dogs/search/?${stringifiedParams}` : `/api/dogs/search/`;
+};
+export const dogsSearchList = async (params, options) => {
+    const res = await fetch(getDogsSearchListUrl(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 getDogsSearchListQueryKey = (params) => {
+    return [
+        `/api/dogs/search/`, ...(params ? [params] : [])
+    ];
+};
+export const getDogsSearchListQueryOptions = (params, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getDogsSearchListQueryKey(params);
+    const queryFn = ({ signal }) => dogsSearchList(params, { signal, ...fetchOptions });
+    return { queryKey, queryFn, ...queryOptions };
+};
+/**
+ * @summary Поиск собак по кличке
+ */
+export function useDogsSearchList(params, options) {
+    const queryOptions = getDogsSearchListQueryOptions(params, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+;
+export const getDogsStatsRetrieveUrl = () => {
+    return `/api/dogs/stats/`;
+};
+export const dogsStatsRetrieve = async (options) => {
+    const res = await fetch(getDogsStatsRetrieveUrl(), {
+        ...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 getDogsStatsRetrieveQueryKey = () => {
+    return [
+        `/api/dogs/stats/`
+    ];
+};
+export const getDogsStatsRetrieveQueryOptions = (options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getDogsStatsRetrieveQueryKey();
+    const queryFn = ({ signal }) => dogsStatsRetrieve({ signal, ...fetchOptions });
+    return { queryKey, queryFn, ...queryOptions };
+};
+/**
+ * @summary Статистика по базе собак
+ */
+export function useDogsStatsRetrieve(options) {
+    const queryOptions = getDogsStatsRetrieveQueryOptions(options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}