@omerikanec/api-client-demo 2.0.3 → 2.0.4

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

@@ -0,0 +1,290 @@
+import type { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import type { Kennel, KennelRequest, MeKennelsListParams, PaginatedKennelList, PatchedKennelRequest } from '../api.schemas';
+type AwaitedInput<T> = PromiseLike<T> | T;
+type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+/**
+ * API питомника пользователя
+ * @summary Список моих питомников
+ */
+export type meKennelsListResponse200 = {
+    data: PaginatedKennelList;
+    status: 200;
+};
+export type meKennelsListResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meKennelsListResponseSuccess = (meKennelsListResponse200) & {
+    headers: Headers;
+};
+export type meKennelsListResponseError = (meKennelsListResponse401) & {
+    headers: Headers;
+};
+export type meKennelsListResponse = (meKennelsListResponseSuccess | meKennelsListResponseError);
+export declare const getMeKennelsListUrl: (params?: MeKennelsListParams) => string;
+export declare const meKennelsList: (params?: MeKennelsListParams, options?: RequestInit) => Promise<meKennelsListResponse>;
+export declare const getMeKennelsListQueryKey: (params?: MeKennelsListParams) => readonly ["/api/me/kennels/", ...MeKennelsListParams[]];
+export declare const getMeKennelsListQueryOptions: <TData = Awaited<ReturnType<typeof meKennelsList>>, TError = void>(params?: MeKennelsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meKennelsList>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof meKennelsList>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type MeKennelsListQueryResult = NonNullable<Awaited<ReturnType<typeof meKennelsList>>>;
+export type MeKennelsListQueryError = void;
+/**
+ * @summary Список моих питомников
+ */
+export declare function useMeKennelsList<TData = Awaited<ReturnType<typeof meKennelsList>>, TError = void>(params?: MeKennelsListParams, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meKennelsList>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * API питомника пользователя
+ * @summary Создать питомник
+ */
+export type meKennelsCreateResponse201 = {
+    data: Kennel;
+    status: 201;
+};
+export type meKennelsCreateResponse400 = {
+    data: void;
+    status: 400;
+};
+export type meKennelsCreateResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meKennelsCreateResponseSuccess = (meKennelsCreateResponse201) & {
+    headers: Headers;
+};
+export type meKennelsCreateResponseError = (meKennelsCreateResponse400 | meKennelsCreateResponse401) & {
+    headers: Headers;
+};
+export type meKennelsCreateResponse = (meKennelsCreateResponseSuccess | meKennelsCreateResponseError);
+export declare const getMeKennelsCreateUrl: () => string;
+export declare const meKennelsCreate: (kennelRequest: KennelRequest, options?: RequestInit) => Promise<meKennelsCreateResponse>;
+export declare const getMeKennelsCreateMutationOptions: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meKennelsCreate>>, TError, {
+        data: KennelRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof meKennelsCreate>>, TError, {
+    data: KennelRequest;
+}, TContext>;
+export type MeKennelsCreateMutationResult = NonNullable<Awaited<ReturnType<typeof meKennelsCreate>>>;
+export type MeKennelsCreateMutationBody = KennelRequest;
+export type MeKennelsCreateMutationError = void;
+/**
+* @summary Создать питомник
+*/
+export declare const useMeKennelsCreate: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meKennelsCreate>>, TError, {
+        data: KennelRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationResult<Awaited<ReturnType<typeof meKennelsCreate>>, TError, {
+    data: KennelRequest;
+}, TContext>;
+/**
+* API питомника пользователя
+* @summary Получить мой питомник по ID
+*/
+export type meKennelsRetrieveResponse200 = {
+    data: Kennel;
+    status: 200;
+};
+export type meKennelsRetrieveResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meKennelsRetrieveResponse404 = {
+    data: void;
+    status: 404;
+};
+export type meKennelsRetrieveResponseSuccess = (meKennelsRetrieveResponse200) & {
+    headers: Headers;
+};
+export type meKennelsRetrieveResponseError = (meKennelsRetrieveResponse401 | meKennelsRetrieveResponse404) & {
+    headers: Headers;
+};
+export type meKennelsRetrieveResponse = (meKennelsRetrieveResponseSuccess | meKennelsRetrieveResponseError);
+export declare const getMeKennelsRetrieveUrl: (id: string) => string;
+export declare const meKennelsRetrieve: (id: string, options?: RequestInit) => Promise<meKennelsRetrieveResponse>;
+export declare const getMeKennelsRetrieveQueryKey: (id: string) => readonly [`/api/me/kennels/${string}/`];
+export declare const getMeKennelsRetrieveQueryOptions: <TData = Awaited<ReturnType<typeof meKennelsRetrieve>>, TError = void>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meKennelsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}) => UseQueryOptions<Awaited<ReturnType<typeof meKennelsRetrieve>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type MeKennelsRetrieveQueryResult = NonNullable<Awaited<ReturnType<typeof meKennelsRetrieve>>>;
+export type MeKennelsRetrieveQueryError = void;
+/**
+ * @summary Получить мой питомник по ID
+ */
+export declare function useMeKennelsRetrieve<TData = Awaited<ReturnType<typeof meKennelsRetrieve>>, TError = void>(id: string, options?: {
+    query?: UseQueryOptions<Awaited<ReturnType<typeof meKennelsRetrieve>>, TError, TData>;
+    fetch?: RequestInit;
+}): UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * API питомника пользователя
+ * @summary Обновить питомник
+ */
+export type meKennelsUpdateResponse200 = {
+    data: Kennel;
+    status: 200;
+};
+export type meKennelsUpdateResponse400 = {
+    data: void;
+    status: 400;
+};
+export type meKennelsUpdateResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meKennelsUpdateResponse404 = {
+    data: void;
+    status: 404;
+};
+export type meKennelsUpdateResponseSuccess = (meKennelsUpdateResponse200) & {
+    headers: Headers;
+};
+export type meKennelsUpdateResponseError = (meKennelsUpdateResponse400 | meKennelsUpdateResponse401 | meKennelsUpdateResponse404) & {
+    headers: Headers;
+};
+export type meKennelsUpdateResponse = (meKennelsUpdateResponseSuccess | meKennelsUpdateResponseError);
+export declare const getMeKennelsUpdateUrl: (id: string) => string;
+export declare const meKennelsUpdate: (id: string, kennelRequest: KennelRequest, options?: RequestInit) => Promise<meKennelsUpdateResponse>;
+export declare const getMeKennelsUpdateMutationOptions: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meKennelsUpdate>>, TError, {
+        id: string;
+        data: KennelRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof meKennelsUpdate>>, TError, {
+    id: string;
+    data: KennelRequest;
+}, TContext>;
+export type MeKennelsUpdateMutationResult = NonNullable<Awaited<ReturnType<typeof meKennelsUpdate>>>;
+export type MeKennelsUpdateMutationBody = KennelRequest;
+export type MeKennelsUpdateMutationError = void;
+/**
+* @summary Обновить питомник
+*/
+export declare const useMeKennelsUpdate: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meKennelsUpdate>>, TError, {
+        id: string;
+        data: KennelRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationResult<Awaited<ReturnType<typeof meKennelsUpdate>>, TError, {
+    id: string;
+    data: KennelRequest;
+}, TContext>;
+/**
+* API питомника пользователя
+* @summary Частично обновить питомник
+*/
+export type meKennelsPartialUpdateResponse200 = {
+    data: Kennel;
+    status: 200;
+};
+export type meKennelsPartialUpdateResponse400 = {
+    data: void;
+    status: 400;
+};
+export type meKennelsPartialUpdateResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meKennelsPartialUpdateResponse404 = {
+    data: void;
+    status: 404;
+};
+export type meKennelsPartialUpdateResponseSuccess = (meKennelsPartialUpdateResponse200) & {
+    headers: Headers;
+};
+export type meKennelsPartialUpdateResponseError = (meKennelsPartialUpdateResponse400 | meKennelsPartialUpdateResponse401 | meKennelsPartialUpdateResponse404) & {
+    headers: Headers;
+};
+export type meKennelsPartialUpdateResponse = (meKennelsPartialUpdateResponseSuccess | meKennelsPartialUpdateResponseError);
+export declare const getMeKennelsPartialUpdateUrl: (id: string) => string;
+export declare const meKennelsPartialUpdate: (id: string, patchedKennelRequest: PatchedKennelRequest, options?: RequestInit) => Promise<meKennelsPartialUpdateResponse>;
+export declare const getMeKennelsPartialUpdateMutationOptions: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meKennelsPartialUpdate>>, TError, {
+        id: string;
+        data: PatchedKennelRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof meKennelsPartialUpdate>>, TError, {
+    id: string;
+    data: PatchedKennelRequest;
+}, TContext>;
+export type MeKennelsPartialUpdateMutationResult = NonNullable<Awaited<ReturnType<typeof meKennelsPartialUpdate>>>;
+export type MeKennelsPartialUpdateMutationBody = PatchedKennelRequest;
+export type MeKennelsPartialUpdateMutationError = void;
+/**
+* @summary Частично обновить питомник
+*/
+export declare const useMeKennelsPartialUpdate: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meKennelsPartialUpdate>>, TError, {
+        id: string;
+        data: PatchedKennelRequest;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationResult<Awaited<ReturnType<typeof meKennelsPartialUpdate>>, TError, {
+    id: string;
+    data: PatchedKennelRequest;
+}, TContext>;
+/**
+* API питомника пользователя
+* @summary Удалить питомник
+*/
+export type meKennelsDestroyResponse204 = {
+    data: void;
+    status: 204;
+};
+export type meKennelsDestroyResponse401 = {
+    data: void;
+    status: 401;
+};
+export type meKennelsDestroyResponse404 = {
+    data: void;
+    status: 404;
+};
+export type meKennelsDestroyResponseSuccess = (meKennelsDestroyResponse204) & {
+    headers: Headers;
+};
+export type meKennelsDestroyResponseError = (meKennelsDestroyResponse401 | meKennelsDestroyResponse404) & {
+    headers: Headers;
+};
+export type meKennelsDestroyResponse = (meKennelsDestroyResponseSuccess | meKennelsDestroyResponseError);
+export declare const getMeKennelsDestroyUrl: (id: string) => string;
+export declare const meKennelsDestroy: (id: string, options?: RequestInit) => Promise<meKennelsDestroyResponse>;
+export declare const getMeKennelsDestroyMutationOptions: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meKennelsDestroy>>, TError, {
+        id: string;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationOptions<Awaited<ReturnType<typeof meKennelsDestroy>>, TError, {
+    id: string;
+}, TContext>;
+export type MeKennelsDestroyMutationResult = NonNullable<Awaited<ReturnType<typeof meKennelsDestroy>>>;
+export type MeKennelsDestroyMutationError = void;
+/**
+* @summary Удалить питомник
+*/
+export declare const useMeKennelsDestroy: <TError = void, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<typeof meKennelsDestroy>>, TError, {
+        id: string;
+    }, TContext>;
+    fetch?: RequestInit;
+}) => UseMutationResult<Awaited<ReturnType<typeof meKennelsDestroy>>, TError, {
+    id: string;
+}, TContext>;
+export {};

package/dist/my-kennels/my-kennels.js

@@ -0,0 +1,207 @@
+/**
+ * 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 getMeKennelsListUrl = (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/kennels/?${stringifiedParams}` : `/api/me/kennels/`;
+};
+export const meKennelsList = async (params, options) => {
+    const res = await fetch(getMeKennelsListUrl(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 getMeKennelsListQueryKey = (params) => {
+    return [
+        `/api/me/kennels/`, ...(params ? [params] : [])
+    ];
+};
+export const getMeKennelsListQueryOptions = (params, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getMeKennelsListQueryKey(params);
+    const queryFn = ({ signal }) => meKennelsList(params, { signal, ...fetchOptions });
+    return { queryKey, queryFn, ...queryOptions };
+};
+/**
+ * @summary Список моих питомников
+ */
+export function useMeKennelsList(params, options) {
+    const queryOptions = getMeKennelsListQueryOptions(params, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+export const getMeKennelsCreateUrl = () => {
+    return `/api/me/kennels/`;
+};
+export const meKennelsCreate = async (kennelRequest, options) => {
+    const res = await fetch(getMeKennelsCreateUrl(), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(kennelRequest)
+    });
+    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 getMeKennelsCreateMutationOptions = (options) => {
+    const mutationKey = ['meKennelsCreate'];
+    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 meKennelsCreate(data, fetchOptions);
+    };
+    return { mutationFn, ...mutationOptions };
+};
+/**
+* @summary Создать питомник
+*/
+export const useMeKennelsCreate = (options) => {
+    return useMutation(getMeKennelsCreateMutationOptions(options));
+};
+export const getMeKennelsRetrieveUrl = (id) => {
+    return `/api/me/kennels/${id}/`;
+};
+export const meKennelsRetrieve = async (id, options) => {
+    const res = await fetch(getMeKennelsRetrieveUrl(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 getMeKennelsRetrieveQueryKey = (id) => {
+    return [
+        `/api/me/kennels/${id}/`
+    ];
+};
+export const getMeKennelsRetrieveQueryOptions = (id, options) => {
+    const { query: queryOptions, fetch: fetchOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getMeKennelsRetrieveQueryKey(id);
+    const queryFn = ({ signal }) => meKennelsRetrieve(id, { signal, ...fetchOptions });
+    return { queryKey, queryFn, enabled: !!(id), ...queryOptions };
+};
+/**
+ * @summary Получить мой питомник по ID
+ */
+export function useMeKennelsRetrieve(id, options) {
+    const queryOptions = getMeKennelsRetrieveQueryOptions(id, options);
+    const query = useQuery(queryOptions);
+    return { ...query, queryKey: queryOptions.queryKey };
+}
+export const getMeKennelsUpdateUrl = (id) => {
+    return `/api/me/kennels/${id}/`;
+};
+export const meKennelsUpdate = async (id, kennelRequest, options) => {
+    const res = await fetch(getMeKennelsUpdateUrl(id), {
+        ...options,
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(kennelRequest)
+    });
+    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 getMeKennelsUpdateMutationOptions = (options) => {
+    const mutationKey = ['meKennelsUpdate'];
+    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 meKennelsUpdate(id, data, fetchOptions);
+    };
+    return { mutationFn, ...mutationOptions };
+};
+/**
+* @summary Обновить питомник
+*/
+export const useMeKennelsUpdate = (options) => {
+    return useMutation(getMeKennelsUpdateMutationOptions(options));
+};
+export const getMeKennelsPartialUpdateUrl = (id) => {
+    return `/api/me/kennels/${id}/`;
+};
+export const meKennelsPartialUpdate = async (id, patchedKennelRequest, options) => {
+    const res = await fetch(getMeKennelsPartialUpdateUrl(id), {
+        ...options,
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(patchedKennelRequest)
+    });
+    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 getMeKennelsPartialUpdateMutationOptions = (options) => {
+    const mutationKey = ['meKennelsPartialUpdate'];
+    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 meKennelsPartialUpdate(id, data, fetchOptions);
+    };
+    return { mutationFn, ...mutationOptions };
+};
+/**
+* @summary Частично обновить питомник
+*/
+export const useMeKennelsPartialUpdate = (options) => {
+    return useMutation(getMeKennelsPartialUpdateMutationOptions(options));
+};
+export const getMeKennelsDestroyUrl = (id) => {
+    return `/api/me/kennels/${id}/`;
+};
+export const meKennelsDestroy = async (id, options) => {
+    const res = await fetch(getMeKennelsDestroyUrl(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 getMeKennelsDestroyMutationOptions = (options) => {
+    const mutationKey = ['meKennelsDestroy'];
+    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 meKennelsDestroy(id, fetchOptions);
+    };
+    return { mutationFn, ...mutationOptions };
+};
+/**
+* @summary Удалить питомник
+*/
+export const useMeKennelsDestroy = (options) => {
+    return useMutation(getMeKennelsDestroyMutationOptions(options));
+};