@omerikanec/api-client-demo 2.0.2 → 2.0.4

package/dist/judges/judges.d.ts

@@ -0,0 +1,147 @@
+import type { QueryKey, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import type { Judge, JudgeDetails, JudgeDetailsListParams, JudgesListParams, PaginatedJudgeDetailsList, PaginatedJudgeList } from '../api.schemas';
+type AwaitedInput<T> = PromiseLike<T> | T;
+type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+/**
+ * API детальных профилей судей
+ * @summary Список детальных профилей судей
+ */
+export type judgeDetailsListResponse200 = {
+    data: PaginatedJudgeDetailsList;
+    status: 200;
+};
+export type judgeDetailsListResponseSuccess = (judgeDetailsListResponse200) & {
+    headers: Headers;
+};
+export type judgeDetailsListResponse = (judgeDetailsListResponseSuccess);
+export declare const getJudgeDetailsListUrl: (params?: JudgeDetailsListParams) => string;
+export declare const judgeDetailsList: (params?: JudgeDetailsListParams, options?: RequestInit) => Promise<judgeDetailsListResponse>;
+export declare const getJudgeDetailsListQueryKey: (params?: JudgeDetailsListParams) => readonly ["/api/judge-details/", ...JudgeDetailsListParams[]];
+export declare const getJudgeDetailsListQueryOptions: <TData = Awaited<ReturnType<typeof judgeDetailsList>>, TError = unknown>(params?: JudgeDetailsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof judgeDetailsList>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof judgeDetailsList>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type JudgeDetailsListQueryResult = NonNullable<Awaited<ReturnType<typeof judgeDetailsList>>>;
+export type JudgeDetailsListQueryError = unknown;
+/**
+ * @summary Список детальных профилей судей
+ */
+export declare function useJudgeDetailsList<TData = Awaited<ReturnType<typeof judgeDetailsList>>, TError = unknown>(params?: JudgeDetailsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof judgeDetailsList>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * API детальных профилей судей
+ * @summary Получить детальный профиль судьи
+ */
+export type judgeDetailsRetrieveResponse200 = {
+    data: JudgeDetails;
+    status: 200;
+};
+export type judgeDetailsRetrieveResponse404 = {
+    data: void;
+    status: 404;
+};
+export type judgeDetailsRetrieveResponseSuccess = (judgeDetailsRetrieveResponse200) & {
+    headers: Headers;
+};
+export type judgeDetailsRetrieveResponseError = (judgeDetailsRetrieveResponse404) & {
+    headers: Headers;
+};
+export type judgeDetailsRetrieveResponse = (judgeDetailsRetrieveResponseSuccess | judgeDetailsRetrieveResponseError);
+export declare const getJudgeDetailsRetrieveUrl: (id: number) => string;
+export declare const judgeDetailsRetrieve: (id: number, options?: RequestInit) => Promise<judgeDetailsRetrieveResponse>;
+export declare const getJudgeDetailsRetrieveQueryKey: (id: number) => readonly [`/api/judge-details/${number}/`];
+export declare const getJudgeDetailsRetrieveQueryOptions: <TData = Awaited<ReturnType<typeof judgeDetailsRetrieve>>, TError = void>(id: number, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof judgeDetailsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof judgeDetailsRetrieve>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type JudgeDetailsRetrieveQueryResult = NonNullable<Awaited<ReturnType<typeof judgeDetailsRetrieve>>>;
+export type JudgeDetailsRetrieveQueryError = void;
+/**
+ * @summary Получить детальный профиль судьи
+ */
+export declare function useJudgeDetailsRetrieve<TData = Awaited<ReturnType<typeof judgeDetailsRetrieve>>, TError = void>(id: number, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof judgeDetailsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * API судей
+ * @summary Список судей
+ */
+export type judgesListResponse200 = {
+    data: PaginatedJudgeList;
+    status: 200;
+};
+export type judgesListResponseSuccess = (judgesListResponse200) & {
+    headers: Headers;
+};
+export type judgesListResponse = (judgesListResponseSuccess);
+export declare const getJudgesListUrl: (params?: JudgesListParams) => string;
+export declare const judgesList: (params?: JudgesListParams, options?: RequestInit) => Promise<judgesListResponse>;
+export declare const getJudgesListQueryKey: (params?: JudgesListParams) => readonly ["/api/judges/", ...JudgesListParams[]];
+export declare const getJudgesListQueryOptions: <TData = Awaited<ReturnType<typeof judgesList>>, TError = unknown>(params?: JudgesListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof judgesList>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof judgesList>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type JudgesListQueryResult = NonNullable<Awaited<ReturnType<typeof judgesList>>>;
+export type JudgesListQueryError = unknown;
+/**
+ * @summary Список судей
+ */
+export declare function useJudgesList<TData = Awaited<ReturnType<typeof judgesList>>, TError = unknown>(params?: JudgesListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof judgesList>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * API судей
+ * @summary Получить судью по ID
+ */
+export type judgesRetrieveResponse200 = {
+    data: Judge;
+    status: 200;
+};
+export type judgesRetrieveResponse404 = {
+    data: void;
+    status: 404;
+};
+export type judgesRetrieveResponseSuccess = (judgesRetrieveResponse200) & {
+    headers: Headers;
+};
+export type judgesRetrieveResponseError = (judgesRetrieveResponse404) & {
+    headers: Headers;
+};
+export type judgesRetrieveResponse = (judgesRetrieveResponseSuccess | judgesRetrieveResponseError);
+export declare const getJudgesRetrieveUrl: (id: number) => string;
+export declare const judgesRetrieve: (id: number, options?: RequestInit) => Promise<judgesRetrieveResponse>;
+export declare const getJudgesRetrieveQueryKey: (id: number) => readonly [`/api/judges/${number}/`];
+export declare const getJudgesRetrieveQueryOptions: <TData = Awaited<ReturnType<typeof judgesRetrieve>>, TError = void>(id: number, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof judgesRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof judgesRetrieve>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type JudgesRetrieveQueryResult = NonNullable<Awaited<ReturnType<typeof judgesRetrieve>>>;
+export type JudgesRetrieveQueryError = void;
+/**
+ * @summary Получить судью по ID
+ */
+export declare function useJudgesRetrieve<TData = Awaited<ReturnType<typeof judgesRetrieve>>, TError = void>(id: number, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof judgesRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};

package/dist/judges/judges.js

@@ -0,0 +1,148 @@
+/**
+ * Generated by orval v8.5.3 🍺
+ * Do not edit manually.
+ * НКП Сибирский Хаски API
+ * API для Национального клуба породы Сибирский хаски
+ * OpenAPI spec version: 1.0.0
+ */
+import { useQuery } from '@tanstack/react-query';
+;
+export const getJudgeDetailsListUrl = (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/judge-details/?${stringifiedParams}` : `/api/judge-details/`;
+};
+export const judgeDetailsList = async (params, options) => {
+    const res = await fetch(getJudgeDetailsListUrl(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 getJudgeDetailsListQueryKey = (params) => {
+    return [
+        `/api/judge-details/`, ...(params ? [params] : [])
+    ];
+};
+export const getJudgeDetailsListQueryOptions = (params, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getJudgeDetailsListQueryKey(params);
+    const queryFn = ({ signal }) => judgeDetailsList(params, { signal, ...fetchOptions });
+    return { queryKey, queryFn, ...queryOptions };
+};
+/**
+ * @summary Список детальных профилей судей
+ */
+export function useJudgeDetailsList(params, options) {
+    const queryOptions = getJudgeDetailsListQueryOptions(params, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+export const getJudgeDetailsRetrieveUrl = (id) => {
+    return `/api/judge-details/${id}/`;
+};
+export const judgeDetailsRetrieve = async (id, options) => {
+    const res = await fetch(getJudgeDetailsRetrieveUrl(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 getJudgeDetailsRetrieveQueryKey = (id) => {
+    return [
+        `/api/judge-details/${id}/`
+    ];
+};
+export const getJudgeDetailsRetrieveQueryOptions = (id, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getJudgeDetailsRetrieveQueryKey(id);
+    const queryFn = ({ signal }) => judgeDetailsRetrieve(id, { signal, ...fetchOptions });
+    return { queryKey, queryFn, enabled: !!(id), ...queryOptions };
+};
+/**
+ * @summary Получить детальный профиль судьи
+ */
+export function useJudgeDetailsRetrieve(id, options) {
+    const queryOptions = getJudgeDetailsRetrieveQueryOptions(id, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+;
+export const getJudgesListUrl = (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/judges/?${stringifiedParams}` : `/api/judges/`;
+};
+export const judgesList = async (params, options) => {
+    const res = await fetch(getJudgesListUrl(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 getJudgesListQueryKey = (params) => {
+    return [
+        `/api/judges/`, ...(params ? [params] : [])
+    ];
+};
+export const getJudgesListQueryOptions = (params, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getJudgesListQueryKey(params);
+    const queryFn = ({ signal }) => judgesList(params, { signal, ...fetchOptions });
+    return { queryKey, queryFn, ...queryOptions };
+};
+/**
+ * @summary Список судей
+ */
+export function useJudgesList(params, options) {
+    const queryOptions = getJudgesListQueryOptions(params, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+export const getJudgesRetrieveUrl = (id) => {
+    return `/api/judges/${id}/`;
+};
+export const judgesRetrieve = async (id, options) => {
+    const res = await fetch(getJudgesRetrieveUrl(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 getJudgesRetrieveQueryKey = (id) => {
+    return [
+        `/api/judges/${id}/`
+    ];
+};
+export const getJudgesRetrieveQueryOptions = (id, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getJudgesRetrieveQueryKey(id);
+    const queryFn = ({ signal }) => judgesRetrieve(id, { signal, ...fetchOptions });
+    return { queryKey, queryFn, enabled: !!(id), ...queryOptions };
+};
+/**
+ * @summary Получить судью по ID
+ */
+export function useJudgesRetrieve(id, options) {
+    const queryOptions = getJudgesRetrieveQueryOptions(id, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}

package/dist/leadership/leadership.d.ts

@@ -0,0 +1,146 @@
+import type { QueryKey, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import type { BoardMember, ClubBoardListParams, PaginatedBoardMemberList, PaginatedWorkingGroupList, WorkingGroup, WorkingGroupsListParams } from '../api.schemas';
+type AwaitedInput<T> = PromiseLike<T> | T;
+type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+/**
+ * API членов Президиума
+ * @summary Список членов Президиума
+ */
+export type clubBoardListResponse200 = {
+    data: PaginatedBoardMemberList;
+    status: 200;
+};
+export type clubBoardListResponseSuccess = (clubBoardListResponse200) & {
+    headers: Headers;
+};
+export type clubBoardListResponse = (clubBoardListResponseSuccess);
+export declare const getClubBoardListUrl: (params?: ClubBoardListParams) => string;
+export declare const clubBoardList: (params?: ClubBoardListParams, options?: RequestInit) => Promise<clubBoardListResponse>;
+export declare const getClubBoardListQueryKey: (params?: ClubBoardListParams) => readonly ["/api/club/board/", ...ClubBoardListParams[]];
+export declare const getClubBoardListQueryOptions: <TData = Awaited<ReturnType<typeof clubBoardList>>, TError = unknown>(params?: ClubBoardListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof clubBoardList>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof clubBoardList>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type ClubBoardListQueryResult = NonNullable<Awaited<ReturnType<typeof clubBoardList>>>;
+export type ClubBoardListQueryError = unknown;
+/**
+ * @summary Список членов Президиума
+ */
+export declare function useClubBoardList<TData = Awaited<ReturnType<typeof clubBoardList>>, TError = unknown>(params?: ClubBoardListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof clubBoardList>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * API членов Президиума
+ * @summary Получить члена Президиума по ID
+ */
+export type clubBoardRetrieveResponse200 = {
+    data: BoardMember;
+    status: 200;
+};
+export type clubBoardRetrieveResponse404 = {
+    data: void;
+    status: 404;
+};
+export type clubBoardRetrieveResponseSuccess = (clubBoardRetrieveResponse200) & {
+    headers: Headers;
+};
+export type clubBoardRetrieveResponseError = (clubBoardRetrieveResponse404) & {
+    headers: Headers;
+};
+export type clubBoardRetrieveResponse = (clubBoardRetrieveResponseSuccess | clubBoardRetrieveResponseError);
+export declare const getClubBoardRetrieveUrl: (id: number) => string;
+export declare const clubBoardRetrieve: (id: number, options?: RequestInit) => Promise<clubBoardRetrieveResponse>;
+export declare const getClubBoardRetrieveQueryKey: (id: number) => readonly [`/api/club/board/${number}/`];
+export declare const getClubBoardRetrieveQueryOptions: <TData = Awaited<ReturnType<typeof clubBoardRetrieve>>, TError = void>(id: number, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof clubBoardRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof clubBoardRetrieve>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type ClubBoardRetrieveQueryResult = NonNullable<Awaited<ReturnType<typeof clubBoardRetrieve>>>;
+export type ClubBoardRetrieveQueryError = void;
+/**
+ * @summary Получить члена Президиума по ID
+ */
+export declare function useClubBoardRetrieve<TData = Awaited<ReturnType<typeof clubBoardRetrieve>>, TError = void>(id: number, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof clubBoardRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * Возвращает рабочие группы вместе с вложенными участниками.
+ * @summary Список рабочих групп
+ */
+export type workingGroupsListResponse200 = {
+    data: PaginatedWorkingGroupList;
+    status: 200;
+};
+export type workingGroupsListResponseSuccess = (workingGroupsListResponse200) & {
+    headers: Headers;
+};
+export type workingGroupsListResponse = (workingGroupsListResponseSuccess);
+export declare const getWorkingGroupsListUrl: (params?: WorkingGroupsListParams) => string;
+export declare const workingGroupsList: (params?: WorkingGroupsListParams, options?: RequestInit) => Promise<workingGroupsListResponse>;
+export declare const getWorkingGroupsListQueryKey: (params?: WorkingGroupsListParams) => readonly ["/api/working-groups/", ...WorkingGroupsListParams[]];
+export declare const getWorkingGroupsListQueryOptions: <TData = Awaited<ReturnType<typeof workingGroupsList>>, TError = unknown>(params?: WorkingGroupsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof workingGroupsList>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof workingGroupsList>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type WorkingGroupsListQueryResult = NonNullable<Awaited<ReturnType<typeof workingGroupsList>>>;
+export type WorkingGroupsListQueryError = unknown;
+/**
+ * @summary Список рабочих групп
+ */
+export declare function useWorkingGroupsList<TData = Awaited<ReturnType<typeof workingGroupsList>>, TError = unknown>(params?: WorkingGroupsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof workingGroupsList>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * @summary Получить рабочую группу по ID
+ */
+export type workingGroupsRetrieveResponse200 = {
+    data: WorkingGroup;
+    status: 200;
+};
+export type workingGroupsRetrieveResponse404 = {
+    data: void;
+    status: 404;
+};
+export type workingGroupsRetrieveResponseSuccess = (workingGroupsRetrieveResponse200) & {
+    headers: Headers;
+};
+export type workingGroupsRetrieveResponseError = (workingGroupsRetrieveResponse404) & {
+    headers: Headers;
+};
+export type workingGroupsRetrieveResponse = (workingGroupsRetrieveResponseSuccess | workingGroupsRetrieveResponseError);
+export declare const getWorkingGroupsRetrieveUrl: (id: number) => string;
+export declare const workingGroupsRetrieve: (id: number, options?: RequestInit) => Promise<workingGroupsRetrieveResponse>;
+export declare const getWorkingGroupsRetrieveQueryKey: (id: number) => readonly [`/api/working-groups/${number}/`];
+export declare const getWorkingGroupsRetrieveQueryOptions: <TData = Awaited<ReturnType<typeof workingGroupsRetrieve>>, TError = void>(id: number, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof workingGroupsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof workingGroupsRetrieve>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type WorkingGroupsRetrieveQueryResult = NonNullable<Awaited<ReturnType<typeof workingGroupsRetrieve>>>;
+export type WorkingGroupsRetrieveQueryError = void;
+/**
+ * @summary Получить рабочую группу по ID
+ */
+export declare function useWorkingGroupsRetrieve<TData = Awaited<ReturnType<typeof workingGroupsRetrieve>>, TError = void>(id: number, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof workingGroupsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};

package/dist/leadership/leadership.js

@@ -0,0 +1,148 @@
+/**
+ * Generated by orval v8.5.3 🍺
+ * Do not edit manually.
+ * НКП Сибирский Хаски API
+ * API для Национального клуба породы Сибирский хаски
+ * OpenAPI spec version: 1.0.0
+ */
+import { useQuery } from '@tanstack/react-query';
+;
+export const getClubBoardListUrl = (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/club/board/?${stringifiedParams}` : `/api/club/board/`;
+};
+export const clubBoardList = async (params, options) => {
+    const res = await fetch(getClubBoardListUrl(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 getClubBoardListQueryKey = (params) => {
+    return [
+        `/api/club/board/`, ...(params ? [params] : [])
+    ];
+};
+export const getClubBoardListQueryOptions = (params, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getClubBoardListQueryKey(params);
+    const queryFn = ({ signal }) => clubBoardList(params, { signal, ...fetchOptions });
+    return { queryKey, queryFn, ...queryOptions };
+};
+/**
+ * @summary Список членов Президиума
+ */
+export function useClubBoardList(params, options) {
+    const queryOptions = getClubBoardListQueryOptions(params, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+export const getClubBoardRetrieveUrl = (id) => {
+    return `/api/club/board/${id}/`;
+};
+export const clubBoardRetrieve = async (id, options) => {
+    const res = await fetch(getClubBoardRetrieveUrl(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 getClubBoardRetrieveQueryKey = (id) => {
+    return [
+        `/api/club/board/${id}/`
+    ];
+};
+export const getClubBoardRetrieveQueryOptions = (id, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getClubBoardRetrieveQueryKey(id);
+    const queryFn = ({ signal }) => clubBoardRetrieve(id, { signal, ...fetchOptions });
+    return { queryKey, queryFn, enabled: !!(id), ...queryOptions };
+};
+/**
+ * @summary Получить члена Президиума по ID
+ */
+export function useClubBoardRetrieve(id, options) {
+    const queryOptions = getClubBoardRetrieveQueryOptions(id, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+;
+export const getWorkingGroupsListUrl = (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/working-groups/?${stringifiedParams}` : `/api/working-groups/`;
+};
+export const workingGroupsList = async (params, options) => {
+    const res = await fetch(getWorkingGroupsListUrl(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 getWorkingGroupsListQueryKey = (params) => {
+    return [
+        `/api/working-groups/`, ...(params ? [params] : [])
+    ];
+};
+export const getWorkingGroupsListQueryOptions = (params, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getWorkingGroupsListQueryKey(params);
+    const queryFn = ({ signal }) => workingGroupsList(params, { signal, ...fetchOptions });
+    return { queryKey, queryFn, ...queryOptions };
+};
+/**
+ * @summary Список рабочих групп
+ */
+export function useWorkingGroupsList(params, options) {
+    const queryOptions = getWorkingGroupsListQueryOptions(params, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+export const getWorkingGroupsRetrieveUrl = (id) => {
+    return `/api/working-groups/${id}/`;
+};
+export const workingGroupsRetrieve = async (id, options) => {
+    const res = await fetch(getWorkingGroupsRetrieveUrl(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 getWorkingGroupsRetrieveQueryKey = (id) => {
+    return [
+        `/api/working-groups/${id}/`
+    ];
+};
+export const getWorkingGroupsRetrieveQueryOptions = (id, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getWorkingGroupsRetrieveQueryKey(id);
+    const queryFn = ({ signal }) => workingGroupsRetrieve(id, { signal, ...fetchOptions });
+    return { queryKey, queryFn, enabled: !!(id), ...queryOptions };
+};
+/**
+ * @summary Получить рабочую группу по ID
+ */
+export function useWorkingGroupsRetrieve(id, options) {
+    const queryOptions = getWorkingGroupsRetrieveQueryOptions(id, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}

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

@@ -0,0 +1,87 @@
+import type { QueryKey, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import type { Achievement, MeAchievementsListParams, PaginatedAchievementList } from '../api.schemas';
+type AwaitedInput<T> = PromiseLike<T> | T;
+type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+/**
+ * API достижений пользователя
+ * @summary Список моих достижений
+ */
+export type meAchievementsListResponse200 = {
+    data: PaginatedAchievementList;
+    status: 200;
+};
+export type meAchievementsListResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meAchievementsListResponseSuccess = (meAchievementsListResponse200) & {
+    headers: Headers;
+};
+export type meAchievementsListResponseError = (meAchievementsListResponse401) & {
+    headers: Headers;
+};
+export type meAchievementsListResponse = (meAchievementsListResponseSuccess | meAchievementsListResponseError);
+export declare const getMeAchievementsListUrl: (params?: MeAchievementsListParams) => string;
+export declare const meAchievementsList: (params?: MeAchievementsListParams, options?: RequestInit) => Promise<meAchievementsListResponse>;
+export declare const getMeAchievementsListQueryKey: (params?: MeAchievementsListParams) => readonly ["/api/me/achievements/", ...MeAchievementsListParams[]];
+export declare const getMeAchievementsListQueryOptions: <TData = Awaited<ReturnType<typeof meAchievementsList>>, TError = void>(params?: MeAchievementsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meAchievementsList>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof meAchievementsList>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type MeAchievementsListQueryResult = NonNullable<Awaited<ReturnType<typeof meAchievementsList>>>;
+export type MeAchievementsListQueryError = void;
+/**
+ * @summary Список моих достижений
+ */
+export declare function useMeAchievementsList<TData = Awaited<ReturnType<typeof meAchievementsList>>, TError = void>(params?: MeAchievementsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meAchievementsList>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * API достижений пользователя
+ * @summary Получить моё достижение по ID
+ */
+export type meAchievementsRetrieveResponse200 = {
+    data: Achievement;
+    status: 200;
+};
+export type meAchievementsRetrieveResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meAchievementsRetrieveResponse404 = {
+    data: void;
+    status: 404;
+};
+export type meAchievementsRetrieveResponseSuccess = (meAchievementsRetrieveResponse200) & {
+    headers: Headers;
+};
+export type meAchievementsRetrieveResponseError = (meAchievementsRetrieveResponse401 | meAchievementsRetrieveResponse404) & {
+    headers: Headers;
+};
+export type meAchievementsRetrieveResponse = (meAchievementsRetrieveResponseSuccess | meAchievementsRetrieveResponseError);
+export declare const getMeAchievementsRetrieveUrl: (id: string) => string;
+export declare const meAchievementsRetrieve: (id: string, options?: RequestInit) => Promise<meAchievementsRetrieveResponse>;
+export declare const getMeAchievementsRetrieveQueryKey: (id: string) => readonly [`/api/me/achievements/${string}/`];
+export declare const getMeAchievementsRetrieveQueryOptions: <TData = Awaited<ReturnType<typeof meAchievementsRetrieve>>, TError = void>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meAchievementsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof meAchievementsRetrieve>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type MeAchievementsRetrieveQueryResult = NonNullable<Awaited<ReturnType<typeof meAchievementsRetrieve>>>;
+export type MeAchievementsRetrieveQueryError = void;
+/**
+ * @summary Получить моё достижение по ID
+ */
+export declare function useMeAchievementsRetrieve<TData = Awaited<ReturnType<typeof meAchievementsRetrieve>>, TError = void>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meAchievementsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};