/**
 * Generated by orval 🍺
 * Do not edit manually.
 * OpenAPI definition
 * OpenAPI spec version: v0
 */
import { openApiFetch } from '../services/openApiFetch';
import type {
  AdminListRequest,
  AdminSlugRequest,
  AuthGetCsrfTokenParams,
  AuthUserDto,
  AwardingDeleteByIdParams,
  AwardingEditDto,
  AwardingGetFormAdminParams,
  AwardingPredSuccDeleteByIdParams,
  AwardingPredSuccEditDto,
  AwardingPredSuccGetFormAdminParams,
  AwardingPredSuccGetParentChildRelationListParams,
  AwardingPredSuccTableDto,
  AwardingTableDto,
  ComboUploadHelperGetAwardingInstance200,
  ComboUploadHelperGetCulturalEntity200,
  ComboUploadHelperGetDateType200,
  ComboUploadHelperGetEventWorksheet200,
  ComboUploadHelperGetInstitute200,
  ComboUploadHelperGetInstituteRedux200,
  ComboUploadHelperGetMetaById200,
  ComboUploadHelperGetMetaByIdParams,
  ComboUploadHelperGetPerson200,
  ComboUploadHelperGetProfession200,
  ContentCollectionDeleteByIdParams,
  ContentCollectionEditDto,
  ContentCollectionGetCollectionParams,
  ContentCollectionGetFormAdminParams,
  ContentCollectionOutputDto,
  ContentCollectionTableDto,
  ContentDto,
  ContentListDto,
  CreationGalleryImageOutDto,
  CreatorStatisticsDto,
  CsrfToken,
  CulturalEntityCopyFromEventParams,
  CulturalEntityDeleteByIdParams,
  CulturalEntityDto,
  CulturalEntityGetDataParams,
  CulturalEntityGetEventsParams,
  CulturalEntityGetFilteredListParams,
  CulturalEntityGetFormAdminParams,
  CulturalEntityListRequest,
  CulturalEntityRelationshipDeleteByIdParams,
  CulturalEntityRelationshipEditDto,
  CulturalEntityRelationshipGetFormAdminParams,
  CulturalEntityRelationshipGetParentChildRelationListParams,
  CulturalEntityRelationshipTableDto,
  CulturalEntitySearch200,
  CulturalEntitySearchParams,
  CulturalEntitySetHighlightedParams,
  CulturalEntityTableDto,
  EventExternalUploadGetComboParams,
  EventExternalUploadGetEventComboParams,
  EventExternalUploadInputDto,
  EventWorksheetGetEventsRequest,
  EventWorksheetOutDto,
  GetArtFormList200,
  ImageFileDto,
  ImageRepositoryDeleteFileParams,
  InstituteDeleteByIdParams,
  InstituteEditDto,
  InstituteGetFormAdminParams,
  InstitutePredSuccDeleteByIdParams,
  InstitutePredSuccEditDto,
  InstitutePredSuccGetFormAdminParams,
  InstitutePredSuccGetParentChildRelationListParams,
  InstitutePredSuccTableDto,
  InstituteReduxCloneInstituteParams,
  InstituteReduxDeleteByIdParams,
  InstituteReduxEditDto,
  InstituteReduxGetComboList200Item,
  InstituteReduxGetFormAdminParams,
  InstituteReduxTableDto,
  InstituteTableDto,
  LoginDto,
  MediaContentAddFileRepo1Body,
  MediaContentAddFileRepo200,
  MediaContentAddFileRepo1200,
  MediaContentAddFileRepoBody,
  MediaContentDeleteByIdParams,
  MediaContentDeleteResultDto,
  MediaContentEditDto,
  MediaContentGetFormAdminParams,
  MediaContentTableDto,
  MetaRequest,
  NamedDto,
  NewsActualOutDto,
  NewsDeleteByIdParams,
  NewsEditDto,
  NewsGetActualsParams,
  NewsGetFormAdminParams,
  NewsTableDto,
  OverviewStatisticsDto,
  PasswordDto,
  PersonAwardingInstanceDeleteByIdParams,
  PersonAwardingInstanceEditDto,
  PersonAwardingInstanceGetAwardDetails200Item,
  PersonAwardingInstanceGetAwardDetailsParams,
  PersonAwardingInstanceGetFormAdminParams,
  PersonAwardingInstanceTableDto,
  PersonDataDto,
  PersonDeleteByIdParams,
  PersonEditDto,
  PersonGetBirthdayInfo200,
  PersonGetBirthdayInfoParams,
  PersonGetCVParams,
  PersonGetDataNewParams,
  PersonGetDataWithRecommendationParams,
  PersonGetFormAdminParams,
  PersonGetFormTranslatorAdminParams,
  PersonGetGraphPersonSubjectWord200,
  PersonGetLifeEventParams,
  PersonGetPersonPersonalDataParams,
  PersonListRequest,
  PersonLookUpDto,
  PersonPersonalDataDto,
  PersonTableDto,
  PersonTranslatorEditDto,
  PersonTranslatorTableDto,
  PersonalNameDeleteByIdParams,
  PersonalNameEditDto,
  PersonalNameGetFormAdminParams,
  PersonalNameTableDto,
  PlaceDeleteByIdParams,
  PlaceEditDto,
  PlaceGetFormAdminParams,
  PlaceTableDto,
  ProgramStatisticsDto,
  ReadOwlCreateCachedContent200,
  ReadOwlCreateCachedContentNew200,
  ReadOwlCreateCachedContentParams,
  ReadOwlGetByParent200Item,
  ReadOwlGetByParentParams,
  ReadOwlLngParams,
  ReadOwlSearch200Item,
  ReadOwlSearchByIdParams,
  ReadOwlSearchParams,
  ScholarshipDeleteByIdParams,
  ScholarshipEditDto,
  ScholarshipGetFormAdminParams,
  ScholarshipTableDto,
  StatGenerate200,
  UserMessageEditDto,
  UserSettingsDeleteByIdParams,
  UserSettingsEditDto,
  UserSettingsGetFormAdminParams,
  UserSettingsGetGroupedValuesParams,
  UserSettingsGetValuesParams,
  UserSettingsRowDto,
  UserSettingsTableDto,
  VideoReferenceCloneVideoReferenceParams,
  VideoReferenceDeleteByIdParams,
  VideoReferenceEditDto,
  VideoReferenceGetFormAdminParams,
  VideoReferenceGetPreview200,
  VideoReferenceGetVideoScheduling200,
  VideoReferencePlayListDeleteByIdParams,
  VideoReferencePlayListEditDto,
  VideoReferencePlayListGetFormAdminParams,
  VideoReferencePlayListTableDto,
  VideoReferenceSendDataToYoutubeParams,
  VideoReferenceSetVideoScheduling200,
  VideoReferenceSetVideoSchedulingBody,
  VideoReferenceTableDto,
  VideoStatisticsDto,
  WalkOfLifeDto,
  WebsitePropertiesDeleteById1Params,
  WebsitePropertiesDeleteByIdParams,
  WebsitePropertiesDto,
  WebsitePropertiesEditDto,
  WebsitePropertiesFindByComponentName1Params,
  WebsitePropertiesFindByComponentNameParams,
  WebsitePropertiesGetFormAdmin1Params,
  WebsitePropertiesGetFormAdminParams,
  WebsitePropertiesTableDto,
} from './models';

// https://stackoverflow.com/questions/49579094/typescript-conditional-types-filter-out-readonly-properties-pick-only-requir/49579497#49579497
type IfEquals<X, Y, A = X, B = never> =
  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? A : B;

type WritableKeys<T> = {
  [P in keyof T]-?: IfEquals<{ [Q in P]: T[P] }, { -readonly [Q in P]: T[P] }, P>;
}[keyof T];

type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void
  ? I
  : never;
type DistributeReadOnlyOverUnions<T> = T extends any ? NonReadonly<T> : never;

type Writable<T> = Pick<T, WritableKeys<T>>;
type NonReadonly<T> = [T] extends [UnionToIntersection<T>]
  ? {
      [P in keyof Writable<T>]: T[P] extends object ? NonReadonly<NonNullable<T[P]>> : T[P];
    }
  : DistributeReadOnlyOverUnions<T>;

export type mediaContentAddFileRepo1Response200 = {
  data: MediaContentAddFileRepo1200;
  status: 200;
};

export type mediaContentAddFileRepo1ResponseSuccess = mediaContentAddFileRepo1Response200 & {
  headers: Headers;
};
export type mediaContentAddFileRepo1Response = mediaContentAddFileRepo1ResponseSuccess;

export const getMediaContentAddFileRepo1Url = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/mediaContentControl/addFileRepo`;
};

export const mediaContentAddFileRepo1 = async (
  mediaContentAddFileRepo1Body?: MediaContentAddFileRepo1Body,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<mediaContentAddFileRepo1Response> => {
  const formData = new FormData();
  if (mediaContentAddFileRepo1Body?.file !== undefined) {
    formData.append(`file`, mediaContentAddFileRepo1Body.file);
  }

  return openApiFetch<mediaContentAddFileRepo1Response>(getMediaContentAddFileRepo1Url(), {
    ...options,
    method: 'PUT',
    body: formData,
  });
};

export type mediaContentAddFileRepoResponse200 = {
  data: MediaContentAddFileRepo200;
  status: 200;
};

export type mediaContentAddFileRepoResponseSuccess = mediaContentAddFileRepoResponse200 & {
  headers: Headers;
};
export type mediaContentAddFileRepoResponse = mediaContentAddFileRepoResponseSuccess;

export const getMediaContentAddFileRepoUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/mediaContentControl/addFileRepo`;
};

export const mediaContentAddFileRepo = async (
  mediaContentAddFileRepoBody?: MediaContentAddFileRepoBody,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<mediaContentAddFileRepoResponse> => {
  const formData = new FormData();
  if (mediaContentAddFileRepoBody?.file !== undefined) {
    formData.append(`file`, mediaContentAddFileRepoBody.file);
  }

  return openApiFetch<mediaContentAddFileRepoResponse>(getMediaContentAddFileRepoUrl(), {
    ...options,
    method: 'POST',
    body: formData,
  });
};

export type websitePropertiesUpdateResponse200 = {
  data: WebsitePropertiesEditDto;
  status: 200;
};

export type websitePropertiesUpdateResponseSuccess = websitePropertiesUpdateResponse200 & {
  headers: Headers;
};
export type websitePropertiesUpdateResponse = websitePropertiesUpdateResponseSuccess;

export const getWebsitePropertiesUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/mmaController/websitePropertiesControl/update`;
};

export const websitePropertiesUpdate = async (
  websitePropertiesEditDto: WebsitePropertiesEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<websitePropertiesUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<websitePropertiesUpdateResponse>(getWebsitePropertiesUpdateUrl(), {
    ...options,
    method: 'PUT',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(websitePropertiesEditDto),
  });
};

export type websitePropertiesUpdate1Response200 = {
  data: WebsitePropertiesEditDto;
  status: 200;
};

export type websitePropertiesUpdate1ResponseSuccess = websitePropertiesUpdate1Response200 & {
  headers: Headers;
};
export type websitePropertiesUpdate1Response = websitePropertiesUpdate1ResponseSuccess;

export const getWebsitePropertiesUpdate1Url = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/websitePropertiesControl/update`;
};

export const websitePropertiesUpdate1 = async (
  websitePropertiesEditDto: WebsitePropertiesEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<websitePropertiesUpdate1Response> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<websitePropertiesUpdate1Response>(getWebsitePropertiesUpdate1Url(), {
    ...options,
    method: 'PUT',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(websitePropertiesEditDto),
  });
};

export type videoReferencePlayListUpdateResponse200 = {
  data: VideoReferencePlayListEditDto;
  status: 200;
};

export type videoReferencePlayListUpdateResponseSuccess =
  videoReferencePlayListUpdateResponse200 & {
    headers: Headers;
  };
export type videoReferencePlayListUpdateResponse = videoReferencePlayListUpdateResponseSuccess;

export const getVideoReferencePlayListUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferencePlayListControl/update`;
};

export const videoReferencePlayListUpdate = async (
  videoReferencePlayListEditDto: VideoReferencePlayListEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferencePlayListUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<videoReferencePlayListUpdateResponse>(getVideoReferencePlayListUpdateUrl(), {
    ...options,
    method: 'PUT',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(videoReferencePlayListEditDto),
  });
};

export type videoReferenceUpdateResponse200 = {
  data: VideoReferenceEditDto;
  status: 200;
};

export type videoReferenceUpdateResponseSuccess = videoReferenceUpdateResponse200 & {
  headers: Headers;
};
export type videoReferenceUpdateResponse = videoReferenceUpdateResponseSuccess;

export const getVideoReferenceUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/update`;
};

export const videoReferenceUpdate = async (
  videoReferenceEditDto: VideoReferenceEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferenceUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<videoReferenceUpdateResponse>(getVideoReferenceUpdateUrl(), {
    ...options,
    method: 'PUT',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(videoReferenceEditDto),
  });
};

export type personUpdateResponse200 = {
  data: PersonEditDto;
  status: 200;
};

export type personUpdateResponseSuccess = personUpdateResponse200 & {
  headers: Headers;
};
export type personUpdateResponse = personUpdateResponseSuccess;

export const getPersonUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/update`;
};

export const personUpdate = async (
  personEditDto: PersonEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<personUpdateResponse>(getPersonUpdateUrl(), {
    ...options,
    method: 'PUT',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(personEditDto),
  });
};

export type personUpdateTranslatorResponse200 = {
  data: PersonTranslatorEditDto;
  status: 200;
};

export type personUpdateTranslatorResponseSuccess = personUpdateTranslatorResponse200 & {
  headers: Headers;
};
export type personUpdateTranslatorResponse = personUpdateTranslatorResponseSuccess;

export const getPersonUpdateTranslatorUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/updateTranslator`;
};

export const personUpdateTranslator = async (
  personTranslatorEditDto: PersonTranslatorEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personUpdateTranslatorResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<personUpdateTranslatorResponse>(getPersonUpdateTranslatorUrl(), {
    ...options,
    method: 'PUT',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(personTranslatorEditDto),
  });
};

export type personPutPersonPersonalDataResponse200 = {
  data: boolean;
  status: 200;
};

export type personPutPersonPersonalDataResponseSuccess = personPutPersonPersonalDataResponse200 & {
  headers: Headers;
};
export type personPutPersonPersonalDataResponse = personPutPersonPersonalDataResponseSuccess;

export const getPersonPutPersonPersonalDataUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/putPersonPersonalData`;
};

export const personPutPersonPersonalData = async (
  personPersonalDataDto: PersonPersonalDataDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personPutPersonPersonalDataResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<personPutPersonPersonalDataResponse>(getPersonPutPersonPersonalDataUrl(), {
    ...options,
    method: 'PUT',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(personPersonalDataDto),
  });
};

export type newsUpdateResponse200 = {
  data: NewsEditDto;
  status: 200;
};

export type newsUpdateResponseSuccess = newsUpdateResponse200 & {
  headers: Headers;
};
export type newsUpdateResponse = newsUpdateResponseSuccess;

export const getNewsUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/newsControl/update`;
};

export const newsUpdate = async (
  newsEditDto: NewsEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<newsUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<newsUpdateResponse>(getNewsUpdateUrl(), {
    ...options,
    method: 'PUT',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(newsEditDto),
  });
};

export type mediaContentUpdateResponse200 = {
  data: MediaContentEditDto;
  status: 200;
};

export type mediaContentUpdateResponseSuccess = mediaContentUpdateResponse200 & {
  headers: Headers;
};
export type mediaContentUpdateResponse = mediaContentUpdateResponseSuccess;

export const getMediaContentUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/mediaContentControl/update`;
};

export const mediaContentUpdate = async (
  mediaContentEditDto: MediaContentEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<mediaContentUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<mediaContentUpdateResponse>(getMediaContentUpdateUrl(), {
    ...options,
    method: 'PUT',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(mediaContentEditDto),
  });
};

export type culturalEntityUpdateResponse200 = {
  data: CulturalEntityDto;
  status: 200;
};

export type culturalEntityUpdateResponseSuccess = culturalEntityUpdateResponse200 & {
  headers: Headers;
};
export type culturalEntityUpdateResponse = culturalEntityUpdateResponseSuccess;

export const getCulturalEntityUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/update`;
};

export const culturalEntityUpdate = async (
  culturalEntityDto: NonReadonly<CulturalEntityDto>,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntityUpdateResponse>(getCulturalEntityUpdateUrl(), {
    ...options,
    method: 'PUT',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(culturalEntityDto),
  });
};

export type awardingUpdateResponse200 = {
  data: AwardingEditDto;
  status: 200;
};

export type awardingUpdateResponseSuccess = awardingUpdateResponse200 & {
  headers: Headers;
};
export type awardingUpdateResponse = awardingUpdateResponseSuccess;

export const getAwardingUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingControl/update`;
};

export const awardingUpdate = async (
  awardingEditDto: AwardingEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<awardingUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<awardingUpdateResponse>(getAwardingUpdateUrl(), {
    ...options,
    method: 'PUT',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(awardingEditDto),
  });
};

export type websitePropertiesSaveResponse200 = {
  data: WebsitePropertiesEditDto;
  status: 200;
};

export type websitePropertiesSaveResponseSuccess = websitePropertiesSaveResponse200 & {
  headers: Headers;
};
export type websitePropertiesSaveResponse = websitePropertiesSaveResponseSuccess;

export const getWebsitePropertiesSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/websitePropertiesControl/save`;
};

export const websitePropertiesSave = async (
  websitePropertiesEditDto: WebsitePropertiesEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<websitePropertiesSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<websitePropertiesSaveResponse>(getWebsitePropertiesSaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(websitePropertiesEditDto),
  });
};

export type websitePropertiesSave1Response200 = {
  data: WebsitePropertiesEditDto;
  status: 200;
};

export type websitePropertiesSave1ResponseSuccess = websitePropertiesSave1Response200 & {
  headers: Headers;
};
export type websitePropertiesSave1Response = websitePropertiesSave1ResponseSuccess;

export const getWebsitePropertiesSave1Url = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/mmaController/websitePropertiesControl/save`;
};

export const websitePropertiesSave1 = async (
  websitePropertiesEditDto: WebsitePropertiesEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<websitePropertiesSave1Response> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<websitePropertiesSave1Response>(getWebsitePropertiesSave1Url(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(websitePropertiesEditDto),
  });
};

export type websitePropertiesGetListAdminResponse200 = {
  data: WebsitePropertiesTableDto;
  status: 200;
};

export type websitePropertiesGetListAdminResponseSuccess =
  websitePropertiesGetListAdminResponse200 & {
    headers: Headers;
  };
export type websitePropertiesGetListAdminResponse = websitePropertiesGetListAdminResponseSuccess;

export const getWebsitePropertiesGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/mmaController/websitePropertiesControl/getListAdmin`;
};

export const websitePropertiesGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<websitePropertiesGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<websitePropertiesGetListAdminResponse>(
    getWebsitePropertiesGetListAdminUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(adminListRequest),
    }
  );
};

export type websitePropertiesGetListAdmin1Response200 = {
  data: WebsitePropertiesTableDto;
  status: 200;
};

export type websitePropertiesGetListAdmin1ResponseSuccess =
  websitePropertiesGetListAdmin1Response200 & {
    headers: Headers;
  };
export type websitePropertiesGetListAdmin1Response = websitePropertiesGetListAdmin1ResponseSuccess;

export const getWebsitePropertiesGetListAdmin1Url = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/websitePropertiesControl/getListAdmin`;
};

export const websitePropertiesGetListAdmin1 = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<websitePropertiesGetListAdmin1Response> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<websitePropertiesGetListAdmin1Response>(
    getWebsitePropertiesGetListAdmin1Url(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(adminListRequest),
    }
  );
};

export type eventWorksheetGetEventsNewResponse200 = {
  data: EventWorksheetOutDto[];
  status: 200;
};

export type eventWorksheetGetEventsNewResponseSuccess = eventWorksheetGetEventsNewResponse200 & {
  headers: Headers;
};
export type eventWorksheetGetEventsNewResponse = eventWorksheetGetEventsNewResponseSuccess;

export const getEventWorksheetGetEventsNewUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/mmaController/eventWorksheetControl/getEventsNew`;
};

export const eventWorksheetGetEventsNew = async (
  eventWorksheetGetEventsRequest: EventWorksheetGetEventsRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<eventWorksheetGetEventsNewResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<eventWorksheetGetEventsNewResponse>(getEventWorksheetGetEventsNewUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(eventWorksheetGetEventsRequest),
  });
};

export type authChangePasswordResponse200 = {
  data: boolean;
  status: 200;
};

export type authChangePasswordResponseSuccess = authChangePasswordResponse200 & {
  headers: Headers;
};
export type authChangePasswordResponse = authChangePasswordResponseSuccess;

export const getAuthChangePasswordUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/changePassword`;
};

export const authChangePassword = async (
  passwordDto: PasswordDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<authChangePasswordResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<authChangePasswordResponse>(getAuthChangePasswordUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(passwordDto),
  });
};

export type videoReferencePlayListSaveResponse200 = {
  data: VideoReferencePlayListEditDto;
  status: 200;
};

export type videoReferencePlayListSaveResponseSuccess = videoReferencePlayListSaveResponse200 & {
  headers: Headers;
};
export type videoReferencePlayListSaveResponse = videoReferencePlayListSaveResponseSuccess;

export const getVideoReferencePlayListSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferencePlayListControl/save`;
};

export const videoReferencePlayListSave = async (
  videoReferencePlayListEditDto: VideoReferencePlayListEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferencePlayListSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<videoReferencePlayListSaveResponse>(getVideoReferencePlayListSaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(videoReferencePlayListEditDto),
  });
};

export type videoReferencePlayListGetListAdminResponse200 = {
  data: VideoReferencePlayListTableDto;
  status: 200;
};

export type videoReferencePlayListGetListAdminResponseSuccess =
  videoReferencePlayListGetListAdminResponse200 & {
    headers: Headers;
  };
export type videoReferencePlayListGetListAdminResponse =
  videoReferencePlayListGetListAdminResponseSuccess;

export const getVideoReferencePlayListGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferencePlayListControl/getListAdmin`;
};

export const videoReferencePlayListGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferencePlayListGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<videoReferencePlayListGetListAdminResponse>(
    getVideoReferencePlayListGetListAdminUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(adminListRequest),
    }
  );
};

export type videoReferenceSetYouTubeSendingStatusResponse200 = {
  data: boolean;
  status: 200;
};

export type videoReferenceSetYouTubeSendingStatusResponseSuccess =
  videoReferenceSetYouTubeSendingStatusResponse200 & {
    headers: Headers;
  };
export type videoReferenceSetYouTubeSendingStatusResponse =
  videoReferenceSetYouTubeSendingStatusResponseSuccess;

export const getVideoReferenceSetYouTubeSendingStatusUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/setYouTubeSendingStatus`;
};

export const videoReferenceSetYouTubeSendingStatus = async (
  videoReferenceSetYouTubeSendingStatusBody: number[],
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferenceSetYouTubeSendingStatusResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<videoReferenceSetYouTubeSendingStatusResponse>(
    getVideoReferenceSetYouTubeSendingStatusUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(videoReferenceSetYouTubeSendingStatusBody),
    }
  );
};

export type videoReferenceSetVideoSchedulingResponse200 = {
  data: VideoReferenceSetVideoScheduling200;
  status: 200;
};

export type videoReferenceSetVideoSchedulingResponseSuccess =
  videoReferenceSetVideoSchedulingResponse200 & {
    headers: Headers;
  };
export type videoReferenceSetVideoSchedulingResponse =
  videoReferenceSetVideoSchedulingResponseSuccess;

export const getVideoReferenceSetVideoSchedulingUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/setVideoScheduling`;
};

export const videoReferenceSetVideoScheduling = async (
  videoReferenceSetVideoSchedulingBody: VideoReferenceSetVideoSchedulingBody,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferenceSetVideoSchedulingResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<videoReferenceSetVideoSchedulingResponse>(
    getVideoReferenceSetVideoSchedulingUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(videoReferenceSetVideoSchedulingBody),
    }
  );
};

export type videoReferenceSendDataToYoutubeResponse200 = {
  data: boolean;
  status: 200;
};

export type videoReferenceSendDataToYoutubeResponseSuccess =
  videoReferenceSendDataToYoutubeResponse200 & {
    headers: Headers;
  };
export type videoReferenceSendDataToYoutubeResponse =
  videoReferenceSendDataToYoutubeResponseSuccess;

export const getVideoReferenceSendDataToYoutubeUrl = (
  params: VideoReferenceSendDataToYoutubeParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/sendDataToYoutube?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/sendDataToYoutube`;
};

export const videoReferenceSendDataToYoutube = async (
  params: VideoReferenceSendDataToYoutubeParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferenceSendDataToYoutubeResponse> => {
  return openApiFetch<videoReferenceSendDataToYoutubeResponse>(
    getVideoReferenceSendDataToYoutubeUrl(params),
    {
      ...options,
      method: 'POST',
    }
  );
};

export type videoReferenceSaveResponse200 = {
  data: VideoReferenceEditDto;
  status: 200;
};

export type videoReferenceSaveResponseSuccess = videoReferenceSaveResponse200 & {
  headers: Headers;
};
export type videoReferenceSaveResponse = videoReferenceSaveResponseSuccess;

export const getVideoReferenceSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/save`;
};

export const videoReferenceSave = async (
  videoReferenceEditDto: VideoReferenceEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferenceSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<videoReferenceSaveResponse>(getVideoReferenceSaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(videoReferenceEditDto),
  });
};

export type videoReferencePullYouTubeDataResponse200 = {
  data: string;
  status: 200;
};

export type videoReferencePullYouTubeDataResponseSuccess =
  videoReferencePullYouTubeDataResponse200 & {
    headers: Headers;
  };
export type videoReferencePullYouTubeDataResponse = videoReferencePullYouTubeDataResponseSuccess;

export const getVideoReferencePullYouTubeDataUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/pullYouTubeData`;
};

export const videoReferencePullYouTubeData = async (
  videoReferencePullYouTubeDataBody: number[],
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferencePullYouTubeDataResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<videoReferencePullYouTubeDataResponse>(
    getVideoReferencePullYouTubeDataUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(videoReferencePullYouTubeDataBody),
    }
  );
};

export type videoReferenceGetVideoSchedulingResponse200 = {
  data: VideoReferenceGetVideoScheduling200;
  status: 200;
};

export type videoReferenceGetVideoSchedulingResponseSuccess =
  videoReferenceGetVideoSchedulingResponse200 & {
    headers: Headers;
  };
export type videoReferenceGetVideoSchedulingResponse =
  videoReferenceGetVideoSchedulingResponseSuccess;

export const getVideoReferenceGetVideoSchedulingUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/getVideoScheduling`;
};

export const videoReferenceGetVideoScheduling = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferenceGetVideoSchedulingResponse> => {
  return openApiFetch<videoReferenceGetVideoSchedulingResponse>(
    getVideoReferenceGetVideoSchedulingUrl(),
    {
      ...options,
      method: 'POST',
    }
  );
};

export type videoReferenceGetPreviewResponse200 = {
  data: VideoReferenceGetPreview200;
  status: 200;
};

export type videoReferenceGetPreviewResponseSuccess = videoReferenceGetPreviewResponse200 & {
  headers: Headers;
};
export type videoReferenceGetPreviewResponse = videoReferenceGetPreviewResponseSuccess;

export const getVideoReferenceGetPreviewUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/getPreview`;
};

export const videoReferenceGetPreview = async (
  videoReferenceEditDto: VideoReferenceEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferenceGetPreviewResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<videoReferenceGetPreviewResponse>(getVideoReferenceGetPreviewUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(videoReferenceEditDto),
  });
};

export type videoReferenceGetListAdminResponse200 = {
  data: VideoReferenceTableDto;
  status: 200;
};

export type videoReferenceGetListAdminResponseSuccess = videoReferenceGetListAdminResponse200 & {
  headers: Headers;
};
export type videoReferenceGetListAdminResponse = videoReferenceGetListAdminResponseSuccess;

export const getVideoReferenceGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/getListAdmin`;
};

export const videoReferenceGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferenceGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<videoReferenceGetListAdminResponse>(getVideoReferenceGetListAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type videoReferenceCreateResponse200 = {
  data: VideoReferenceEditDto;
  status: 200;
};

export type videoReferenceCreateResponseSuccess = videoReferenceCreateResponse200 & {
  headers: Headers;
};
export type videoReferenceCreateResponse = videoReferenceCreateResponseSuccess;

export const getVideoReferenceCreateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/create`;
};

export const videoReferenceCreate = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferenceCreateResponse> => {
  return openApiFetch<videoReferenceCreateResponse>(getVideoReferenceCreateUrl(), {
    ...options,
    method: 'POST',
  });
};

export type videoReferenceCloneVideoReferenceResponse200 = {
  data: boolean;
  status: 200;
};

export type videoReferenceCloneVideoReferenceResponseSuccess =
  videoReferenceCloneVideoReferenceResponse200 & {
    headers: Headers;
  };
export type videoReferenceCloneVideoReferenceResponse =
  videoReferenceCloneVideoReferenceResponseSuccess;

export const getVideoReferenceCloneVideoReferenceUrl = (
  params: VideoReferenceCloneVideoReferenceParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/cloneVideoReference?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/cloneVideoReference`;
};

export const videoReferenceCloneVideoReference = async (
  params: VideoReferenceCloneVideoReferenceParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferenceCloneVideoReferenceResponse> => {
  return openApiFetch<videoReferenceCloneVideoReferenceResponse>(
    getVideoReferenceCloneVideoReferenceUrl(params),
    {
      ...options,
      method: 'POST',
    }
  );
};

export type userSettingsSaveOrUpdateResponse200 = {
  data: UserSettingsEditDto;
  status: 200;
};

export type userSettingsSaveOrUpdateResponseSuccess = userSettingsSaveOrUpdateResponse200 & {
  headers: Headers;
};
export type userSettingsSaveOrUpdateResponse = userSettingsSaveOrUpdateResponseSuccess;

export const getUserSettingsSaveOrUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/userSettingsControl/update`;
};

export const userSettingsSaveOrUpdate = async (
  userSettingsEditDto: NonReadonly<UserSettingsEditDto>,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<userSettingsSaveOrUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<userSettingsSaveOrUpdateResponse>(getUserSettingsSaveOrUpdateUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(userSettingsEditDto),
  });
};

export type userSettingsSaveOrUpdate1Response200 = {
  data: UserSettingsEditDto;
  status: 200;
};

export type userSettingsSaveOrUpdate1ResponseSuccess = userSettingsSaveOrUpdate1Response200 & {
  headers: Headers;
};
export type userSettingsSaveOrUpdate1Response = userSettingsSaveOrUpdate1ResponseSuccess;

export const getUserSettingsSaveOrUpdate1Url = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/userSettingsControl/save`;
};

export const userSettingsSaveOrUpdate1 = async (
  userSettingsEditDto: NonReadonly<UserSettingsEditDto>,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<userSettingsSaveOrUpdate1Response> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<userSettingsSaveOrUpdate1Response>(getUserSettingsSaveOrUpdate1Url(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(userSettingsEditDto),
  });
};

export type userSettingsGetListAdminResponse200 = {
  data: UserSettingsTableDto;
  status: 200;
};

export type userSettingsGetListAdminResponseSuccess = userSettingsGetListAdminResponse200 & {
  headers: Headers;
};
export type userSettingsGetListAdminResponse = userSettingsGetListAdminResponseSuccess;

export const getUserSettingsGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/userSettingsControl/getListAdmin`;
};

export const userSettingsGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<userSettingsGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<userSettingsGetListAdminResponse>(getUserSettingsGetListAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type userMessageSaveResponse200 = {
  data: UserMessageEditDto;
  status: 200;
};

export type userMessageSaveResponseSuccess = userMessageSaveResponse200 & {
  headers: Headers;
};
export type userMessageSaveResponse = userMessageSaveResponseSuccess;

export const getUserMessageSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/userMessageControl/save`;
};

export const userMessageSave = async (
  userMessageEditDto: UserMessageEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<userMessageSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<userMessageSaveResponse>(getUserMessageSaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(userMessageEditDto),
  });
};

export type statGenerateResponse200 = {
  data: StatGenerate200;
  status: 200;
};

export type statGenerateResponseSuccess = statGenerateResponse200 & {
  headers: Headers;
};
export type statGenerateResponse = statGenerateResponseSuccess;

export const getStatGenerateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/statControl/generate`;
};

export const statGenerate = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<statGenerateResponse> => {
  return openApiFetch<statGenerateResponse>(getStatGenerateUrl(), {
    ...options,
    method: 'POST',
  });
};

export type scholarshipUpdateResponse200 = {
  data: ScholarshipEditDto;
  status: 200;
};

export type scholarshipUpdateResponseSuccess = scholarshipUpdateResponse200 & {
  headers: Headers;
};
export type scholarshipUpdateResponse = scholarshipUpdateResponseSuccess;

export const getScholarshipUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/scholarshipControl/update`;
};

export const scholarshipUpdate = async (
  scholarshipEditDto: ScholarshipEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<scholarshipUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<scholarshipUpdateResponse>(getScholarshipUpdateUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(scholarshipEditDto),
  });
};

export type scholarshipSaveResponse200 = {
  data: ScholarshipEditDto;
  status: 200;
};

export type scholarshipSaveResponseSuccess = scholarshipSaveResponse200 & {
  headers: Headers;
};
export type scholarshipSaveResponse = scholarshipSaveResponseSuccess;

export const getScholarshipSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/scholarshipControl/save`;
};

export const scholarshipSave = async (
  scholarshipEditDto: ScholarshipEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<scholarshipSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<scholarshipSaveResponse>(getScholarshipSaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(scholarshipEditDto),
  });
};

export type scholarshipGetListAdminResponse200 = {
  data: ScholarshipTableDto;
  status: 200;
};

export type scholarshipGetListAdminResponseSuccess = scholarshipGetListAdminResponse200 & {
  headers: Headers;
};
export type scholarshipGetListAdminResponse = scholarshipGetListAdminResponseSuccess;

export const getScholarshipGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/scholarshipControl/getListAdmin`;
};

export const scholarshipGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<scholarshipGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<scholarshipGetListAdminResponse>(getScholarshipGetListAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type placeUpdateResponse200 = {
  data: PlaceEditDto;
  status: 200;
};

export type placeUpdateResponseSuccess = placeUpdateResponse200 & {
  headers: Headers;
};
export type placeUpdateResponse = placeUpdateResponseSuccess;

export const getPlaceUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/placeControl/update`;
};

export const placeUpdate = async (
  placeEditDto: PlaceEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<placeUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<placeUpdateResponse>(getPlaceUpdateUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(placeEditDto),
  });
};

export type placeSaveResponse200 = {
  data: PlaceEditDto;
  status: 200;
};

export type placeSaveResponseSuccess = placeSaveResponse200 & {
  headers: Headers;
};
export type placeSaveResponse = placeSaveResponseSuccess;

export const getPlaceSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/placeControl/save`;
};

export const placeSave = async (
  placeEditDto: PlaceEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<placeSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<placeSaveResponse>(getPlaceSaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(placeEditDto),
  });
};

export type placeGetListAdminResponse200 = {
  data: PlaceTableDto;
  status: 200;
};

export type placeGetListAdminResponseSuccess = placeGetListAdminResponse200 & {
  headers: Headers;
};
export type placeGetListAdminResponse = placeGetListAdminResponseSuccess;

export const getPlaceGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/placeControl/getListAdmin`;
};

export const placeGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<placeGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<placeGetListAdminResponse>(getPlaceGetListAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type personalNameSaveOrUpdateResponse200 = {
  data: PersonalNameEditDto;
  status: 200;
};

export type personalNameSaveOrUpdateResponseSuccess = personalNameSaveOrUpdateResponse200 & {
  headers: Headers;
};
export type personalNameSaveOrUpdateResponse = personalNameSaveOrUpdateResponseSuccess;

export const getPersonalNameSaveOrUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personalNameControl/saveOrUpdate`;
};

export const personalNameSaveOrUpdate = async (
  personalNameEditDto: PersonalNameEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personalNameSaveOrUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<personalNameSaveOrUpdateResponse>(getPersonalNameSaveOrUpdateUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(personalNameEditDto),
  });
};

export type personalNameGetListAdminResponse200 = {
  data: PersonalNameTableDto;
  status: 200;
};

export type personalNameGetListAdminResponseSuccess = personalNameGetListAdminResponse200 & {
  headers: Headers;
};
export type personalNameGetListAdminResponse = personalNameGetListAdminResponseSuccess;

export const getPersonalNameGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personalNameControl/getListAdmin`;
};

export const personalNameGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personalNameGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<personalNameGetListAdminResponse>(getPersonalNameGetListAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type personGetAllResponse200 = {
  data: PersonEditDto[];
  status: 200;
};

export type personGetAllResponseSuccess = personGetAllResponse200 & {
  headers: Headers;
};
export type personGetAllResponse = personGetAllResponseSuccess;

export const getPersonGetAllUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl`;
};

export const personGetAll = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personGetAllResponse> => {
  return openApiFetch<personGetAllResponse>(getPersonGetAllUrl(), {
    ...options,
    method: 'GET',
  });
};

export type personCreateUserResponse200 = {
  data: PersonEditDto;
  status: 200;
};

export type personCreateUserResponseSuccess = personCreateUserResponse200 & {
  headers: Headers;
};
export type personCreateUserResponse = personCreateUserResponseSuccess;

export const getPersonCreateUserUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl`;
};

export const personCreateUser = async (
  personEditDto: PersonEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personCreateUserResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<personCreateUserResponse>(getPersonCreateUserUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(personEditDto),
  });
};

export type personSaveResponse200 = {
  data: PersonEditDto;
  status: 200;
};

export type personSaveResponseSuccess = personSaveResponse200 & {
  headers: Headers;
};
export type personSaveResponse = personSaveResponseSuccess;

export const getPersonSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/save`;
};

export const personSave = async (
  personEditDto: PersonEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<personSaveResponse>(getPersonSaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(personEditDto),
  });
};

export type personGetPersonPersonalDataResponse200 = {
  data: PersonPersonalDataDto;
  status: 200;
};

export type personGetPersonPersonalDataResponseSuccess = personGetPersonPersonalDataResponse200 & {
  headers: Headers;
};
export type personGetPersonPersonalDataResponse = personGetPersonPersonalDataResponseSuccess;

export const getPersonGetPersonPersonalDataUrl = (params: PersonGetPersonPersonalDataParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getPersonPersonalData?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getPersonPersonalData`;
};

export const personGetPersonPersonalData = async (
  params: PersonGetPersonPersonalDataParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personGetPersonPersonalDataResponse> => {
  return openApiFetch<personGetPersonPersonalDataResponse>(
    getPersonGetPersonPersonalDataUrl(params),
    {
      ...options,
      method: 'POST',
    }
  );
};

export type personGetListResponse200 = {
  data: PersonLookUpDto[];
  status: 200;
};

export type personGetListResponseSuccess = personGetListResponse200 & {
  headers: Headers;
};
export type personGetListResponse = personGetListResponseSuccess;

export const getPersonGetListUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getList`;
};

export const personGetList = async (
  personListRequest: PersonListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personGetListResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<personGetListResponse>(getPersonGetListUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(personListRequest),
  });
};

export type personGetListTranslatorAdminResponse200 = {
  data: PersonTranslatorTableDto;
  status: 200;
};

export type personGetListTranslatorAdminResponseSuccess =
  personGetListTranslatorAdminResponse200 & {
    headers: Headers;
  };
export type personGetListTranslatorAdminResponse = personGetListTranslatorAdminResponseSuccess;

export const getPersonGetListTranslatorAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getListTranslatorAdmin`;
};

export const personGetListTranslatorAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personGetListTranslatorAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<personGetListTranslatorAdminResponse>(getPersonGetListTranslatorAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type personGetListAdminResponse200 = {
  data: PersonTableDto;
  status: 200;
};

export type personGetListAdminResponseSuccess = personGetListAdminResponse200 & {
  headers: Headers;
};
export type personGetListAdminResponse = personGetListAdminResponseSuccess;

export const getPersonGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getListAdmin`;
};

export const personGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<personGetListAdminResponse>(getPersonGetListAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type personAwardingInstanceSaveResponse200 = {
  data: PersonAwardingInstanceEditDto;
  status: 200;
};

export type personAwardingInstanceSaveResponseSuccess = personAwardingInstanceSaveResponse200 & {
  headers: Headers;
};
export type personAwardingInstanceSaveResponse = personAwardingInstanceSaveResponseSuccess;

export const getPersonAwardingInstanceSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personAwardingInstanceControl/save`;
};

export const personAwardingInstanceSave = async (
  personAwardingInstanceEditDto: PersonAwardingInstanceEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personAwardingInstanceSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<personAwardingInstanceSaveResponse>(getPersonAwardingInstanceSaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(personAwardingInstanceEditDto),
  });
};

export type personAwardingInstanceGetListAdminResponse200 = {
  data: PersonAwardingInstanceTableDto;
  status: 200;
};

export type personAwardingInstanceGetListAdminResponseSuccess =
  personAwardingInstanceGetListAdminResponse200 & {
    headers: Headers;
  };
export type personAwardingInstanceGetListAdminResponse =
  personAwardingInstanceGetListAdminResponseSuccess;

export const getPersonAwardingInstanceGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personAwardingInstanceControl/getListAdmin`;
};

export const personAwardingInstanceGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personAwardingInstanceGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<personAwardingInstanceGetListAdminResponse>(
    getPersonAwardingInstanceGetListAdminUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(adminListRequest),
    }
  );
};

export type newsSaveResponse200 = {
  data: NewsEditDto;
  status: 200;
};

export type newsSaveResponseSuccess = newsSaveResponse200 & {
  headers: Headers;
};
export type newsSaveResponse = newsSaveResponseSuccess;

export const getNewsSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/newsControl/save`;
};

export const newsSave = async (
  newsEditDto: NewsEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<newsSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<newsSaveResponse>(getNewsSaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(newsEditDto),
  });
};

export type newsGetListAdminResponse200 = {
  data: NewsTableDto;
  status: 200;
};

export type newsGetListAdminResponseSuccess = newsGetListAdminResponse200 & {
  headers: Headers;
};
export type newsGetListAdminResponse = newsGetListAdminResponseSuccess;

export const getNewsGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/newsControl/getListAdmin`;
};

export const newsGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<newsGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<newsGetListAdminResponse>(getNewsGetListAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type metaAttributeComponentGetMetaComboResponse200 = {
  data: NamedDto[];
  status: 200;
};

export type metaAttributeComponentGetMetaComboResponseSuccess =
  metaAttributeComponentGetMetaComboResponse200 & {
    headers: Headers;
  };
export type metaAttributeComponentGetMetaComboResponse =
  metaAttributeComponentGetMetaComboResponseSuccess;

export const getMetaAttributeComponentGetMetaComboUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/metaAttributeComponentControl/getMetaCombo`;
};

export const metaAttributeComponentGetMetaCombo = async (
  metaRequest: MetaRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<metaAttributeComponentGetMetaComboResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<metaAttributeComponentGetMetaComboResponse>(
    getMetaAttributeComponentGetMetaComboUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(metaRequest),
    }
  );
};

export type mediaContentSaveResponse200 = {
  data: MediaContentEditDto;
  status: 200;
};

export type mediaContentSaveResponseSuccess = mediaContentSaveResponse200 & {
  headers: Headers;
};
export type mediaContentSaveResponse = mediaContentSaveResponseSuccess;

export const getMediaContentSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/mediaContentControl/save`;
};

export const mediaContentSave = async (
  mediaContentEditDto: MediaContentEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<mediaContentSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<mediaContentSaveResponse>(getMediaContentSaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(mediaContentEditDto),
  });
};

export type mediaContentGetListAdminResponse200 = {
  data: MediaContentTableDto;
  status: 200;
};

export type mediaContentGetListAdminResponseSuccess = mediaContentGetListAdminResponse200 & {
  headers: Headers;
};
export type mediaContentGetListAdminResponse = mediaContentGetListAdminResponseSuccess;

export const getMediaContentGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/mediaContentControl/getListAdmin`;
};

export const mediaContentGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<mediaContentGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<mediaContentGetListAdminResponse>(getMediaContentGetListAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type mediaContentGetImageResponse200 = {
  data: CreationGalleryImageOutDto;
  status: 200;
};

export type mediaContentGetImageResponseSuccess = mediaContentGetImageResponse200 & {
  headers: Headers;
};
export type mediaContentGetImageResponse = mediaContentGetImageResponseSuccess;

export const getMediaContentGetImageUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/mediaContentControl/getImage`;
};

export const mediaContentGetImage = async (
  mediaContentGetImageBody: number,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<mediaContentGetImageResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<mediaContentGetImageResponse>(getMediaContentGetImageUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(mediaContentGetImageBody),
  });
};

export type mediaContentGetImageListByPersonResponse200 = {
  data: CreationGalleryImageOutDto[];
  status: 200;
};

export type mediaContentGetImageListByPersonResponseSuccess =
  mediaContentGetImageListByPersonResponse200 & {
    headers: Headers;
  };
export type mediaContentGetImageListByPersonResponse =
  mediaContentGetImageListByPersonResponseSuccess;

export const getMediaContentGetImageListByPersonUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/mediaContentControl/getImageListByPerson`;
};

export const mediaContentGetImageListByPerson = async (
  mediaContentGetImageListByPersonBody: number,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<mediaContentGetImageListByPersonResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<mediaContentGetImageListByPersonResponse>(
    getMediaContentGetImageListByPersonUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(mediaContentGetImageListByPersonBody),
    }
  );
};

export type mediaContentGetImageListByContentResponse200 = {
  data: CreationGalleryImageOutDto[];
  status: 200;
};

export type mediaContentGetImageListByContentResponseSuccess =
  mediaContentGetImageListByContentResponse200 & {
    headers: Headers;
  };
export type mediaContentGetImageListByContentResponse =
  mediaContentGetImageListByContentResponseSuccess;

export const getMediaContentGetImageListByContentUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/mediaContentControl/getImageListByContent`;
};

export const mediaContentGetImageListByContent = async (
  mediaContentGetImageListByContentBody: number,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<mediaContentGetImageListByContentResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<mediaContentGetImageListByContentResponse>(
    getMediaContentGetImageListByContentUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(mediaContentGetImageListByContentBody),
    }
  );
};

export type authLogoutResponse200 = {
  data: void;
  status: 200;
};

export type authLogoutResponseSuccess = authLogoutResponse200 & {
  headers: Headers;
};
export type authLogoutResponse = authLogoutResponseSuccess;

export const getAuthLogoutUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/logout`;
};

export const authLogout = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<authLogoutResponse> => {
  return openApiFetch<authLogoutResponse>(getAuthLogoutUrl(), {
    ...options,
    method: 'POST',
  });
};

export type authLoginResponse200 = {
  data: void;
  status: 200;
};

export type authLoginResponseSuccess = authLoginResponse200 & {
  headers: Headers;
};
export type authLoginResponse = authLoginResponseSuccess;

export const getAuthLoginUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/login`;
};

export const authLogin = async (
  loginDto: LoginDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<authLoginResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<authLoginResponse>(getAuthLoginUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(loginDto),
  });
};

export type instituteReduxSaveOrUpdateResponse200 = {
  data: InstituteReduxEditDto;
  status: 200;
};

export type instituteReduxSaveOrUpdateResponseSuccess = instituteReduxSaveOrUpdateResponse200 & {
  headers: Headers;
};
export type instituteReduxSaveOrUpdateResponse = instituteReduxSaveOrUpdateResponseSuccess;

export const getInstituteReduxSaveOrUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteReduxControl/saveOrUpdate`;
};

export const instituteReduxSaveOrUpdate = async (
  instituteReduxEditDto: InstituteReduxEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<instituteReduxSaveOrUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<instituteReduxSaveOrUpdateResponse>(getInstituteReduxSaveOrUpdateUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(instituteReduxEditDto),
  });
};

export type instituteReduxGetListAdminResponse200 = {
  data: InstituteReduxTableDto;
  status: 200;
};

export type instituteReduxGetListAdminResponseSuccess = instituteReduxGetListAdminResponse200 & {
  headers: Headers;
};
export type instituteReduxGetListAdminResponse = instituteReduxGetListAdminResponseSuccess;

export const getInstituteReduxGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteReduxControl/getListAdmin`;
};

export const instituteReduxGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<instituteReduxGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<instituteReduxGetListAdminResponse>(getInstituteReduxGetListAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type instituteReduxCloneInstituteResponse200 = {
  data: boolean;
  status: 200;
};

export type instituteReduxCloneInstituteResponseSuccess =
  instituteReduxCloneInstituteResponse200 & {
    headers: Headers;
  };
export type instituteReduxCloneInstituteResponse = instituteReduxCloneInstituteResponseSuccess;

export const getInstituteReduxCloneInstituteUrl = (params: InstituteReduxCloneInstituteParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteReduxControl/cloneInstitute?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteReduxControl/cloneInstitute`;
};

export const instituteReduxCloneInstitute = async (
  params: InstituteReduxCloneInstituteParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<instituteReduxCloneInstituteResponse> => {
  return openApiFetch<instituteReduxCloneInstituteResponse>(
    getInstituteReduxCloneInstituteUrl(params),
    {
      ...options,
      method: 'POST',
    }
  );
};

export type institutePredSuccUpdateResponse200 = {
  data: InstitutePredSuccEditDto;
  status: 200;
};

export type institutePredSuccUpdateResponseSuccess = institutePredSuccUpdateResponse200 & {
  headers: Headers;
};
export type institutePredSuccUpdateResponse = institutePredSuccUpdateResponseSuccess;

export const getInstitutePredSuccUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/institutePredSuccControl/update`;
};

export const institutePredSuccUpdate = async (
  institutePredSuccEditDto: InstitutePredSuccEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<institutePredSuccUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<institutePredSuccUpdateResponse>(getInstitutePredSuccUpdateUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(institutePredSuccEditDto),
  });
};

export type institutePredSuccSaveResponse200 = {
  data: InstitutePredSuccEditDto;
  status: 200;
};

export type institutePredSuccSaveResponseSuccess = institutePredSuccSaveResponse200 & {
  headers: Headers;
};
export type institutePredSuccSaveResponse = institutePredSuccSaveResponseSuccess;

export const getInstitutePredSuccSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/institutePredSuccControl/save`;
};

export const institutePredSuccSave = async (
  institutePredSuccEditDto: InstitutePredSuccEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<institutePredSuccSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<institutePredSuccSaveResponse>(getInstitutePredSuccSaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(institutePredSuccEditDto),
  });
};

export type institutePredSuccGetParentChildRelationListResponse200 = {
  data: number[];
  status: 200;
};

export type institutePredSuccGetParentChildRelationListResponseSuccess =
  institutePredSuccGetParentChildRelationListResponse200 & {
    headers: Headers;
  };
export type institutePredSuccGetParentChildRelationListResponse =
  institutePredSuccGetParentChildRelationListResponseSuccess;

export const getInstitutePredSuccGetParentChildRelationListUrl = (
  params: InstitutePredSuccGetParentChildRelationListParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/institutePredSuccControl/getParentChildRelationList?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/institutePredSuccControl/getParentChildRelationList`;
};

export const institutePredSuccGetParentChildRelationList = async (
  params: InstitutePredSuccGetParentChildRelationListParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<institutePredSuccGetParentChildRelationListResponse> => {
  return openApiFetch<institutePredSuccGetParentChildRelationListResponse>(
    getInstitutePredSuccGetParentChildRelationListUrl(params),
    {
      ...options,
      method: 'POST',
    }
  );
};

export type institutePredSuccGetListAdminResponse200 = {
  data: InstitutePredSuccTableDto;
  status: 200;
};

export type institutePredSuccGetListAdminResponseSuccess =
  institutePredSuccGetListAdminResponse200 & {
    headers: Headers;
  };
export type institutePredSuccGetListAdminResponse = institutePredSuccGetListAdminResponseSuccess;

export const getInstitutePredSuccGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/institutePredSuccControl/getListAdmin`;
};

export const institutePredSuccGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<institutePredSuccGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<institutePredSuccGetListAdminResponse>(
    getInstitutePredSuccGetListAdminUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(adminListRequest),
    }
  );
};

export type instituteSaveOrUpdateResponse200 = {
  data: InstituteEditDto;
  status: 200;
};

export type instituteSaveOrUpdateResponseSuccess = instituteSaveOrUpdateResponse200 & {
  headers: Headers;
};
export type instituteSaveOrUpdateResponse = instituteSaveOrUpdateResponseSuccess;

export const getInstituteSaveOrUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteControl/saveOrUpdate`;
};

export const instituteSaveOrUpdate = async (
  instituteEditDto: InstituteEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<instituteSaveOrUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<instituteSaveOrUpdateResponse>(getInstituteSaveOrUpdateUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(instituteEditDto),
  });
};

export type instituteGetListAdminResponse200 = {
  data: InstituteTableDto;
  status: 200;
};

export type instituteGetListAdminResponseSuccess = instituteGetListAdminResponse200 & {
  headers: Headers;
};
export type instituteGetListAdminResponse = instituteGetListAdminResponseSuccess;

export const getInstituteGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteControl/getListAdmin`;
};

export const instituteGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<instituteGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<instituteGetListAdminResponse>(getInstituteGetListAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type imageRepositoryUploadFileResponse200 = {
  data: string;
  status: 200;
};

export type imageRepositoryUploadFileResponseSuccess = imageRepositoryUploadFileResponse200 & {
  headers: Headers;
};
export type imageRepositoryUploadFileResponse = imageRepositoryUploadFileResponseSuccess;

export const getImageRepositoryUploadFileUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/imageRepository/uploadFile`;
};

export const imageRepositoryUploadFile = async (
  imageFileDto: ImageFileDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<imageRepositoryUploadFileResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<imageRepositoryUploadFileResponse>(getImageRepositoryUploadFileUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(imageFileDto),
  });
};

export type eventExternalUploadSendDataResponse200 = {
  data: boolean;
  status: 200;
};

export type eventExternalUploadSendDataResponseSuccess = eventExternalUploadSendDataResponse200 & {
  headers: Headers;
};
export type eventExternalUploadSendDataResponse = eventExternalUploadSendDataResponseSuccess;

export const getEventExternalUploadSendDataUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/eventExternalUploadControl/sendData`;
};

export const eventExternalUploadSendData = async (
  eventExternalUploadInputDto: EventExternalUploadInputDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<eventExternalUploadSendDataResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<eventExternalUploadSendDataResponse>(getEventExternalUploadSendDataUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(eventExternalUploadInputDto),
  });
};

export type culturalEntityRelationshipUpdateResponse200 = {
  data: CulturalEntityRelationshipEditDto;
  status: 200;
};

export type culturalEntityRelationshipUpdateResponseSuccess =
  culturalEntityRelationshipUpdateResponse200 & {
    headers: Headers;
  };
export type culturalEntityRelationshipUpdateResponse =
  culturalEntityRelationshipUpdateResponseSuccess;

export const getCulturalEntityRelationshipUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityRelationshipControl/update`;
};

export const culturalEntityRelationshipUpdate = async (
  culturalEntityRelationshipEditDto: CulturalEntityRelationshipEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityRelationshipUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntityRelationshipUpdateResponse>(
    getCulturalEntityRelationshipUpdateUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(culturalEntityRelationshipEditDto),
    }
  );
};

export type culturalEntityRelationshipSaveResponse200 = {
  data: CulturalEntityRelationshipEditDto;
  status: 200;
};

export type culturalEntityRelationshipSaveResponseSuccess =
  culturalEntityRelationshipSaveResponse200 & {
    headers: Headers;
  };
export type culturalEntityRelationshipSaveResponse = culturalEntityRelationshipSaveResponseSuccess;

export const getCulturalEntityRelationshipSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityRelationshipControl/save`;
};

export const culturalEntityRelationshipSave = async (
  culturalEntityRelationshipEditDto: CulturalEntityRelationshipEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityRelationshipSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntityRelationshipSaveResponse>(
    getCulturalEntityRelationshipSaveUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(culturalEntityRelationshipEditDto),
    }
  );
};

export type culturalEntityRelationshipGetParentChildRelationListResponse200 = {
  data: number[];
  status: 200;
};

export type culturalEntityRelationshipGetParentChildRelationListResponseSuccess =
  culturalEntityRelationshipGetParentChildRelationListResponse200 & {
    headers: Headers;
  };
export type culturalEntityRelationshipGetParentChildRelationListResponse =
  culturalEntityRelationshipGetParentChildRelationListResponseSuccess;

export const getCulturalEntityRelationshipGetParentChildRelationListUrl = (
  params: CulturalEntityRelationshipGetParentChildRelationListParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityRelationshipControl/getParentChildRelationList?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityRelationshipControl/getParentChildRelationList`;
};

export const culturalEntityRelationshipGetParentChildRelationList = async (
  params: CulturalEntityRelationshipGetParentChildRelationListParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityRelationshipGetParentChildRelationListResponse> => {
  return openApiFetch<culturalEntityRelationshipGetParentChildRelationListResponse>(
    getCulturalEntityRelationshipGetParentChildRelationListUrl(params),
    {
      ...options,
      method: 'POST',
    }
  );
};

export type culturalEntityRelationshipGetListAdminResponse200 = {
  data: CulturalEntityRelationshipTableDto;
  status: 200;
};

export type culturalEntityRelationshipGetListAdminResponseSuccess =
  culturalEntityRelationshipGetListAdminResponse200 & {
    headers: Headers;
  };
export type culturalEntityRelationshipGetListAdminResponse =
  culturalEntityRelationshipGetListAdminResponseSuccess;

export const getCulturalEntityRelationshipGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityRelationshipControl/getListAdmin`;
};

export const culturalEntityRelationshipGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityRelationshipGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntityRelationshipGetListAdminResponse>(
    getCulturalEntityRelationshipGetListAdminUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(adminListRequest),
    }
  );
};

export type culturalEntitySetHighlightedResponse200 = {
  data: boolean;
  status: 200;
};

export type culturalEntitySetHighlightedResponseSuccess =
  culturalEntitySetHighlightedResponse200 & {
    headers: Headers;
  };
export type culturalEntitySetHighlightedResponse = culturalEntitySetHighlightedResponseSuccess;

export const getCulturalEntitySetHighlightedUrl = (params: CulturalEntitySetHighlightedParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/setHighlighted?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/setHighlighted`;
};

export const culturalEntitySetHighlighted = async (
  culturalEntitySetHighlightedBody: number[],
  params: CulturalEntitySetHighlightedParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntitySetHighlightedResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntitySetHighlightedResponse>(
    getCulturalEntitySetHighlightedUrl(params),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(culturalEntitySetHighlightedBody),
    }
  );
};

export type culturalEntitySaveResponse200 = {
  data: CulturalEntityDto;
  status: 200;
};

export type culturalEntitySaveResponseSuccess = culturalEntitySaveResponse200 & {
  headers: Headers;
};
export type culturalEntitySaveResponse = culturalEntitySaveResponseSuccess;

export const getCulturalEntitySaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/save`;
};

export const culturalEntitySave = async (
  culturalEntityDto: NonReadonly<CulturalEntityDto>,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntitySaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntitySaveResponse>(getCulturalEntitySaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(culturalEntityDto),
  });
};

export type culturalEntityGetListResponse200 = {
  data: ContentListDto[];
  status: 200;
};

export type culturalEntityGetListResponseSuccess = culturalEntityGetListResponse200 & {
  headers: Headers;
};
export type culturalEntityGetListResponse = culturalEntityGetListResponseSuccess;

export const getCulturalEntityGetListUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/getList`;
};

export const culturalEntityGetList = async (
  culturalEntityListRequest: CulturalEntityListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityGetListResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntityGetListResponse>(getCulturalEntityGetListUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(culturalEntityListRequest),
  });
};

export type culturalEntityGetListAdminResponse200 = {
  data: CulturalEntityTableDto;
  status: 200;
};

export type culturalEntityGetListAdminResponseSuccess = culturalEntityGetListAdminResponse200 & {
  headers: Headers;
};
export type culturalEntityGetListAdminResponse = culturalEntityGetListAdminResponseSuccess;

export const getCulturalEntityGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/getListAdmin`;
};

export const culturalEntityGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntityGetListAdminResponse>(getCulturalEntityGetListAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type culturalEntityGetListAdminOldResponse200 = {
  data: CulturalEntityTableDto;
  status: 200;
};

export type culturalEntityGetListAdminOldResponseSuccess =
  culturalEntityGetListAdminOldResponse200 & {
    headers: Headers;
  };
export type culturalEntityGetListAdminOldResponse = culturalEntityGetListAdminOldResponseSuccess;

export const getCulturalEntityGetListAdminOldUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/getListAdminOld`;
};

/**
 * @deprecated
 */
export const culturalEntityGetListAdminOld = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityGetListAdminOldResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntityGetListAdminOldResponse>(
    getCulturalEntityGetListAdminOldUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(adminListRequest),
    }
  );
};

export type culturalEntityGetEventBySlugResponse200 = {
  data: EventWorksheetOutDto;
  status: 200;
};

export type culturalEntityGetEventBySlugResponseSuccess =
  culturalEntityGetEventBySlugResponse200 & {
    headers: Headers;
  };
export type culturalEntityGetEventBySlugResponse = culturalEntityGetEventBySlugResponseSuccess;

export const getCulturalEntityGetEventBySlugUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/getEventBySlug`;
};

export const culturalEntityGetEventBySlug = async (
  adminSlugRequest: AdminSlugRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityGetEventBySlugResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntityGetEventBySlugResponse>(getCulturalEntityGetEventBySlugUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminSlugRequest),
  });
};

export type culturalEntityCopyFromEventResponse200 = {
  data: CulturalEntityDto[];
  status: 200;
};

export type culturalEntityCopyFromEventResponseSuccess = culturalEntityCopyFromEventResponse200 & {
  headers: Headers;
};
export type culturalEntityCopyFromEventResponse = culturalEntityCopyFromEventResponseSuccess;

export const getCulturalEntityCopyFromEventUrl = (params?: CulturalEntityCopyFromEventParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/copyFromEvent?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/copyFromEvent`;
};

export const culturalEntityCopyFromEvent = async (
  culturalEntityCopyFromEventBody?: number[],
  params?: CulturalEntityCopyFromEventParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityCopyFromEventResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntityCopyFromEventResponse>(
    getCulturalEntityCopyFromEventUrl(params),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(culturalEntityCopyFromEventBody),
    }
  );
};

export type culturalEntityCopyFromEventWorksheetResponse200 = {
  data: CulturalEntityDto[];
  status: 200;
};

export type culturalEntityCopyFromEventWorksheetResponseSuccess =
  culturalEntityCopyFromEventWorksheetResponse200 & {
    headers: Headers;
  };
export type culturalEntityCopyFromEventWorksheetResponse =
  culturalEntityCopyFromEventWorksheetResponseSuccess;

export const getCulturalEntityCopyFromEventWorksheetUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/copyFromEventWorksheet`;
};

export const culturalEntityCopyFromEventWorksheet = async (
  culturalEntityCopyFromEventWorksheetBody: number[],
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityCopyFromEventWorksheetResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntityCopyFromEventWorksheetResponse>(
    getCulturalEntityCopyFromEventWorksheetUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(culturalEntityCopyFromEventWorksheetBody),
    }
  );
};

export type culturalEntityCopyFromContentResponse200 = {
  data: CulturalEntityDto[];
  status: 200;
};

export type culturalEntityCopyFromContentResponseSuccess =
  culturalEntityCopyFromContentResponse200 & {
    headers: Headers;
  };
export type culturalEntityCopyFromContentResponse = culturalEntityCopyFromContentResponseSuccess;

export const getCulturalEntityCopyFromContentUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/copyFromContent`;
};

export const culturalEntityCopyFromContent = async (
  culturalEntityCopyFromContentBody: number[],
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityCopyFromContentResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntityCopyFromContentResponse>(
    getCulturalEntityCopyFromContentUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(culturalEntityCopyFromContentBody),
    }
  );
};

export type culturalEntityCopyFromContentByCreatorResponse200 = {
  data: boolean;
  status: 200;
};

export type culturalEntityCopyFromContentByCreatorResponseSuccess =
  culturalEntityCopyFromContentByCreatorResponse200 & {
    headers: Headers;
  };
export type culturalEntityCopyFromContentByCreatorResponse =
  culturalEntityCopyFromContentByCreatorResponseSuccess;

export const getCulturalEntityCopyFromContentByCreatorUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/copyFromContentByCreator`;
};

export const culturalEntityCopyFromContentByCreator = async (
  culturalEntityCopyFromContentByCreatorBody: number[],
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityCopyFromContentByCreatorResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntityCopyFromContentByCreatorResponse>(
    getCulturalEntityCopyFromContentByCreatorUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(culturalEntityCopyFromContentByCreatorBody),
    }
  );
};

export type culturalEntityCopyFromContentByCreatorStartResponse200 = {
  data: boolean;
  status: 200;
};

export type culturalEntityCopyFromContentByCreatorStartResponseSuccess =
  culturalEntityCopyFromContentByCreatorStartResponse200 & {
    headers: Headers;
  };
export type culturalEntityCopyFromContentByCreatorStartResponse =
  culturalEntityCopyFromContentByCreatorStartResponseSuccess;

export const getCulturalEntityCopyFromContentByCreatorStartUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/copyFromContentByCreatorStart`;
};

export const culturalEntityCopyFromContentByCreatorStart = async (
  culturalEntityCopyFromContentByCreatorStartBody: number[],
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityCopyFromContentByCreatorStartResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<culturalEntityCopyFromContentByCreatorStartResponse>(
    getCulturalEntityCopyFromContentByCreatorStartUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(culturalEntityCopyFromContentByCreatorStartBody),
    }
  );
};

export type contentCollectionSaveOrUpdateResponse200 = {
  data: ContentCollectionEditDto;
  status: 200;
};

export type contentCollectionSaveOrUpdateResponseSuccess =
  contentCollectionSaveOrUpdateResponse200 & {
    headers: Headers;
  };
export type contentCollectionSaveOrUpdateResponse = contentCollectionSaveOrUpdateResponseSuccess;

export const getContentCollectionSaveOrUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/contentCollectionControl/saveOrUpdate`;
};

export const contentCollectionSaveOrUpdate = async (
  contentCollectionEditDto: ContentCollectionEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<contentCollectionSaveOrUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<contentCollectionSaveOrUpdateResponse>(
    getContentCollectionSaveOrUpdateUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(contentCollectionEditDto),
    }
  );
};

export type contentCollectionGetListAdminResponse200 = {
  data: ContentCollectionTableDto;
  status: 200;
};

export type contentCollectionGetListAdminResponseSuccess =
  contentCollectionGetListAdminResponse200 & {
    headers: Headers;
  };
export type contentCollectionGetListAdminResponse = contentCollectionGetListAdminResponseSuccess;

export const getContentCollectionGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/contentCollectionControl/getListAdmin`;
};

export const contentCollectionGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<contentCollectionGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<contentCollectionGetListAdminResponse>(
    getContentCollectionGetListAdminUrl(),
    {
      ...options,
      method: 'POST',
      headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
      body: JSON.stringify(adminListRequest),
    }
  );
};

export type awardingPredSuccUpdateResponse200 = {
  data: AwardingPredSuccEditDto;
  status: 200;
};

export type awardingPredSuccUpdateResponseSuccess = awardingPredSuccUpdateResponse200 & {
  headers: Headers;
};
export type awardingPredSuccUpdateResponse = awardingPredSuccUpdateResponseSuccess;

export const getAwardingPredSuccUpdateUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingPredSuccControl/update`;
};

export const awardingPredSuccUpdate = async (
  awardingPredSuccEditDto: AwardingPredSuccEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<awardingPredSuccUpdateResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<awardingPredSuccUpdateResponse>(getAwardingPredSuccUpdateUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(awardingPredSuccEditDto),
  });
};

export type awardingPredSuccSaveResponse200 = {
  data: AwardingPredSuccEditDto;
  status: 200;
};

export type awardingPredSuccSaveResponseSuccess = awardingPredSuccSaveResponse200 & {
  headers: Headers;
};
export type awardingPredSuccSaveResponse = awardingPredSuccSaveResponseSuccess;

export const getAwardingPredSuccSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingPredSuccControl/save`;
};

export const awardingPredSuccSave = async (
  awardingPredSuccEditDto: AwardingPredSuccEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<awardingPredSuccSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<awardingPredSuccSaveResponse>(getAwardingPredSuccSaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(awardingPredSuccEditDto),
  });
};

export type awardingPredSuccGetParentChildRelationListResponse200 = {
  data: number[];
  status: 200;
};

export type awardingPredSuccGetParentChildRelationListResponseSuccess =
  awardingPredSuccGetParentChildRelationListResponse200 & {
    headers: Headers;
  };
export type awardingPredSuccGetParentChildRelationListResponse =
  awardingPredSuccGetParentChildRelationListResponseSuccess;

export const getAwardingPredSuccGetParentChildRelationListUrl = (
  params: AwardingPredSuccGetParentChildRelationListParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingPredSuccControl/getParentChildRelationList?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingPredSuccControl/getParentChildRelationList`;
};

export const awardingPredSuccGetParentChildRelationList = async (
  params: AwardingPredSuccGetParentChildRelationListParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<awardingPredSuccGetParentChildRelationListResponse> => {
  return openApiFetch<awardingPredSuccGetParentChildRelationListResponse>(
    getAwardingPredSuccGetParentChildRelationListUrl(params),
    {
      ...options,
      method: 'POST',
    }
  );
};

export type awardingPredSuccGetListAdminResponse200 = {
  data: AwardingPredSuccTableDto;
  status: 200;
};

export type awardingPredSuccGetListAdminResponseSuccess =
  awardingPredSuccGetListAdminResponse200 & {
    headers: Headers;
  };
export type awardingPredSuccGetListAdminResponse = awardingPredSuccGetListAdminResponseSuccess;

export const getAwardingPredSuccGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingPredSuccControl/getListAdmin`;
};

export const awardingPredSuccGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<awardingPredSuccGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<awardingPredSuccGetListAdminResponse>(getAwardingPredSuccGetListAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type awardingSaveResponse200 = {
  data: AwardingEditDto;
  status: 200;
};

export type awardingSaveResponseSuccess = awardingSaveResponse200 & {
  headers: Headers;
};
export type awardingSaveResponse = awardingSaveResponseSuccess;

export const getAwardingSaveUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingControl/save`;
};

export const awardingSave = async (
  awardingEditDto: AwardingEditDto,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<awardingSaveResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<awardingSaveResponse>(getAwardingSaveUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(awardingEditDto),
  });
};

export type awardingGetListAdminResponse200 = {
  data: AwardingTableDto;
  status: 200;
};

export type awardingGetListAdminResponseSuccess = awardingGetListAdminResponse200 & {
  headers: Headers;
};
export type awardingGetListAdminResponse = awardingGetListAdminResponseSuccess;

export const getAwardingGetListAdminUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingControl/getListAdmin`;
};

export const awardingGetListAdmin = async (
  adminListRequest: AdminListRequest,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<awardingGetListAdminResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<awardingGetListAdminResponse>(getAwardingGetListAdminUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(adminListRequest),
  });
};

export type awardingAcceptResponse200 = {
  data: AwardingEditDto;
  status: 200;
};

export type awardingAcceptResponseSuccess = awardingAcceptResponse200 & {
  headers: Headers;
};
export type awardingAcceptResponse = awardingAcceptResponseSuccess;

export const getAwardingAcceptUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingControl/accept`;
};

export const awardingAccept = async (
  awardingAcceptBody: number,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<awardingAcceptResponse> => {
  const getHeaders = (
    h?: NonNullable<RequestInit['headers']>
  ): Record<string, string | readonly string[]> => {
    if (!h) return {};
    if (h instanceof Headers) return Object.fromEntries(h.entries());
    if (Symbol.iterator in h) {
      return Object.fromEntries(
        Array.from(
          h as Iterable<Iterable<string>>,
          (entry) => Array.from(entry) as [string, string]
        )
      );
    }
    const headers: Record<string, string | readonly string[]> = {};
    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
      if (value !== undefined) headers[name] = value;
    }
    return headers;
  };
  return openApiFetch<awardingAcceptResponse>(getAwardingAcceptUrl(), {
    ...options,
    method: 'POST',
    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
    body: JSON.stringify(awardingAcceptBody),
  });
};

export type websitePropertiesGetFormAdminResponse200 = {
  data: WebsitePropertiesEditDto;
  status: 200;
};

export type websitePropertiesGetFormAdminResponseSuccess =
  websitePropertiesGetFormAdminResponse200 & {
    headers: Headers;
  };
export type websitePropertiesGetFormAdminResponse = websitePropertiesGetFormAdminResponseSuccess;

export const getWebsitePropertiesGetFormAdminUrl = (
  params: WebsitePropertiesGetFormAdminParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/mmaController/websitePropertiesControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/mmaController/websitePropertiesControl/getFormAdmin`;
};

export const websitePropertiesGetFormAdmin = async (
  params: WebsitePropertiesGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<websitePropertiesGetFormAdminResponse> => {
  return openApiFetch<websitePropertiesGetFormAdminResponse>(
    getWebsitePropertiesGetFormAdminUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type websitePropertiesGetFormAdmin1Response200 = {
  data: WebsitePropertiesEditDto;
  status: 200;
};

export type websitePropertiesGetFormAdmin1ResponseSuccess =
  websitePropertiesGetFormAdmin1Response200 & {
    headers: Headers;
  };
export type websitePropertiesGetFormAdmin1Response = websitePropertiesGetFormAdmin1ResponseSuccess;

export const getWebsitePropertiesGetFormAdmin1Url = (
  params: WebsitePropertiesGetFormAdmin1Params
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/websitePropertiesControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/websitePropertiesControl/getFormAdmin`;
};

export const websitePropertiesGetFormAdmin1 = async (
  params: WebsitePropertiesGetFormAdmin1Params,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<websitePropertiesGetFormAdmin1Response> => {
  return openApiFetch<websitePropertiesGetFormAdmin1Response>(
    getWebsitePropertiesGetFormAdmin1Url(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type websitePropertiesFindByComponentNameResponse200 = {
  data: WebsitePropertiesDto[];
  status: 200;
};

export type websitePropertiesFindByComponentNameResponseSuccess =
  websitePropertiesFindByComponentNameResponse200 & {
    headers: Headers;
  };
export type websitePropertiesFindByComponentNameResponse =
  websitePropertiesFindByComponentNameResponseSuccess;

export const getWebsitePropertiesFindByComponentNameUrl = (
  params: WebsitePropertiesFindByComponentNameParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/mmaController/websitePropertiesControl/findByComponentName?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/mmaController/websitePropertiesControl/findByComponentName`;
};

export const websitePropertiesFindByComponentName = async (
  params: WebsitePropertiesFindByComponentNameParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<websitePropertiesFindByComponentNameResponse> => {
  return openApiFetch<websitePropertiesFindByComponentNameResponse>(
    getWebsitePropertiesFindByComponentNameUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type websitePropertiesFindByComponentName1Response200 = {
  data: WebsitePropertiesDto[];
  status: 200;
};

export type websitePropertiesFindByComponentName1ResponseSuccess =
  websitePropertiesFindByComponentName1Response200 & {
    headers: Headers;
  };
export type websitePropertiesFindByComponentName1Response =
  websitePropertiesFindByComponentName1ResponseSuccess;

export const getWebsitePropertiesFindByComponentName1Url = (
  params: WebsitePropertiesFindByComponentName1Params
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/websitePropertiesControl/findByComponentName?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/websitePropertiesControl/findByComponentName`;
};

export const websitePropertiesFindByComponentName1 = async (
  params: WebsitePropertiesFindByComponentName1Params,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<websitePropertiesFindByComponentName1Response> => {
  return openApiFetch<websitePropertiesFindByComponentName1Response>(
    getWebsitePropertiesFindByComponentName1Url(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type loginPageResponse200 = {
  data: string;
  status: 200;
};

export type loginPageResponseSuccess = loginPageResponse200 & {
  headers: Headers;
};
export type loginPageResponse = loginPageResponseSuccess;

export const getLoginPageUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/login`;
};

export const loginPage = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<loginPageResponse> => {
  return openApiFetch<loginPageResponse>(getLoginPageUrl(), {
    ...options,
    method: 'GET',
  });
};

export type videoReferencePlayListGetListSelectionResponse200 = {
  data: NamedDto[];
  status: 200;
};

export type videoReferencePlayListGetListSelectionResponseSuccess =
  videoReferencePlayListGetListSelectionResponse200 & {
    headers: Headers;
  };
export type videoReferencePlayListGetListSelectionResponse =
  videoReferencePlayListGetListSelectionResponseSuccess;

export const getVideoReferencePlayListGetListSelectionUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferencePlayListControl/getListSelection`;
};

export const videoReferencePlayListGetListSelection = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferencePlayListGetListSelectionResponse> => {
  return openApiFetch<videoReferencePlayListGetListSelectionResponse>(
    getVideoReferencePlayListGetListSelectionUrl(),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type videoReferencePlayListGetFormAdminResponse200 = {
  data: VideoReferencePlayListEditDto;
  status: 200;
};

export type videoReferencePlayListGetFormAdminResponseSuccess =
  videoReferencePlayListGetFormAdminResponse200 & {
    headers: Headers;
  };
export type videoReferencePlayListGetFormAdminResponse =
  videoReferencePlayListGetFormAdminResponseSuccess;

export const getVideoReferencePlayListGetFormAdminUrl = (
  params: VideoReferencePlayListGetFormAdminParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferencePlayListControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferencePlayListControl/getFormAdmin`;
};

export const videoReferencePlayListGetFormAdmin = async (
  params: VideoReferencePlayListGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferencePlayListGetFormAdminResponse> => {
  return openApiFetch<videoReferencePlayListGetFormAdminResponse>(
    getVideoReferencePlayListGetFormAdminUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type videoReferenceTestResponse200 = {
  data: CulturalEntityDto;
  status: 200;
};

export type videoReferenceTestResponseSuccess = videoReferenceTestResponse200 & {
  headers: Headers;
};
export type videoReferenceTestResponse = videoReferenceTestResponseSuccess;

export const getVideoReferenceTestUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/test`;
};

export const videoReferenceTest = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferenceTestResponse> => {
  return openApiFetch<videoReferenceTestResponse>(getVideoReferenceTestUrl(), {
    ...options,
    method: 'GET',
  });
};

export type videoReferenceGetFormAdminResponse200 = {
  data: VideoReferenceEditDto;
  status: 200;
};

export type videoReferenceGetFormAdminResponseSuccess = videoReferenceGetFormAdminResponse200 & {
  headers: Headers;
};
export type videoReferenceGetFormAdminResponse = videoReferenceGetFormAdminResponseSuccess;

export const getVideoReferenceGetFormAdminUrl = (params: VideoReferenceGetFormAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/getFormAdmin`;
};

export const videoReferenceGetFormAdmin = async (
  params: VideoReferenceGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferenceGetFormAdminResponse> => {
  return openApiFetch<videoReferenceGetFormAdminResponse>(
    getVideoReferenceGetFormAdminUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type videoReferenceDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type videoReferenceDeleteByIdResponseSuccess = videoReferenceDeleteByIdResponse200 & {
  headers: Headers;
};
export type videoReferenceDeleteByIdResponse = videoReferenceDeleteByIdResponseSuccess;

export const getVideoReferenceDeleteByIdUrl = (params: VideoReferenceDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferenceControl/deleteById`;
};

export const videoReferenceDeleteById = async (
  params: VideoReferenceDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferenceDeleteByIdResponse> => {
  return openApiFetch<videoReferenceDeleteByIdResponse>(getVideoReferenceDeleteByIdUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type userSettingsGetValuesResponse200 = {
  data: UserSettingsRowDto[];
  status: 200;
};

export type userSettingsGetValuesResponseSuccess = userSettingsGetValuesResponse200 & {
  headers: Headers;
};
export type userSettingsGetValuesResponse = userSettingsGetValuesResponseSuccess;

export const getUserSettingsGetValuesUrl = (params: UserSettingsGetValuesParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/userSettingsControl/getValues?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/userSettingsControl/getValues`;
};

export const userSettingsGetValues = async (
  params: UserSettingsGetValuesParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<userSettingsGetValuesResponse> => {
  return openApiFetch<userSettingsGetValuesResponse>(getUserSettingsGetValuesUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type userSettingsGetGroupedValuesResponse200 = {
  data: UserSettingsRowDto[];
  status: 200;
};

export type userSettingsGetGroupedValuesResponseSuccess =
  userSettingsGetGroupedValuesResponse200 & {
    headers: Headers;
  };
export type userSettingsGetGroupedValuesResponse = userSettingsGetGroupedValuesResponseSuccess;

export const getUserSettingsGetGroupedValuesUrl = (params: UserSettingsGetGroupedValuesParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/userSettingsControl/getGroupedValues?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/userSettingsControl/getGroupedValues`;
};

export const userSettingsGetGroupedValues = async (
  params: UserSettingsGetGroupedValuesParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<userSettingsGetGroupedValuesResponse> => {
  return openApiFetch<userSettingsGetGroupedValuesResponse>(
    getUserSettingsGetGroupedValuesUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type userSettingsGetFormAdminResponse200 = {
  data: UserSettingsEditDto;
  status: 200;
};

export type userSettingsGetFormAdminResponseSuccess = userSettingsGetFormAdminResponse200 & {
  headers: Headers;
};
export type userSettingsGetFormAdminResponse = userSettingsGetFormAdminResponseSuccess;

export const getUserSettingsGetFormAdminUrl = (params: UserSettingsGetFormAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/userSettingsControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/userSettingsControl/getFormAdmin`;
};

export const userSettingsGetFormAdmin = async (
  params: UserSettingsGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<userSettingsGetFormAdminResponse> => {
  return openApiFetch<userSettingsGetFormAdminResponse>(getUserSettingsGetFormAdminUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type statisticsGetVideoResponse200 = {
  data: VideoStatisticsDto;
  status: 200;
};

export type statisticsGetVideoResponseSuccess = statisticsGetVideoResponse200 & {
  headers: Headers;
};
export type statisticsGetVideoResponse = statisticsGetVideoResponseSuccess;

export const getStatisticsGetVideoUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/statControl/getVideo`;
};

export const statisticsGetVideo = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<statisticsGetVideoResponse> => {
  return openApiFetch<statisticsGetVideoResponse>(getStatisticsGetVideoUrl(), {
    ...options,
    method: 'GET',
  });
};

export type statisticsGetProgramsResponse200 = {
  data: ProgramStatisticsDto;
  status: 200;
};

export type statisticsGetProgramsResponseSuccess = statisticsGetProgramsResponse200 & {
  headers: Headers;
};
export type statisticsGetProgramsResponse = statisticsGetProgramsResponseSuccess;

export const getStatisticsGetProgramsUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/statControl/getPrograms`;
};

export const statisticsGetPrograms = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<statisticsGetProgramsResponse> => {
  return openApiFetch<statisticsGetProgramsResponse>(getStatisticsGetProgramsUrl(), {
    ...options,
    method: 'GET',
  });
};

export type statisticsGetOverviewResponse200 = {
  data: OverviewStatisticsDto;
  status: 200;
};

export type statisticsGetOverviewResponseSuccess = statisticsGetOverviewResponse200 & {
  headers: Headers;
};
export type statisticsGetOverviewResponse = statisticsGetOverviewResponseSuccess;

export const getStatisticsGetOverviewUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/statControl/getOverview`;
};

export const statisticsGetOverview = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<statisticsGetOverviewResponse> => {
  return openApiFetch<statisticsGetOverviewResponse>(getStatisticsGetOverviewUrl(), {
    ...options,
    method: 'GET',
  });
};

export type statisticsGetCreatorsResponse200 = {
  data: CreatorStatisticsDto;
  status: 200;
};

export type statisticsGetCreatorsResponseSuccess = statisticsGetCreatorsResponse200 & {
  headers: Headers;
};
export type statisticsGetCreatorsResponse = statisticsGetCreatorsResponseSuccess;

export const getStatisticsGetCreatorsUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/statControl/getCreators`;
};

export const statisticsGetCreators = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<statisticsGetCreatorsResponse> => {
  return openApiFetch<statisticsGetCreatorsResponse>(getStatisticsGetCreatorsUrl(), {
    ...options,
    method: 'GET',
  });
};

export type scholarshipGetFormAdminResponse200 = {
  data: ScholarshipEditDto;
  status: 200;
};

export type scholarshipGetFormAdminResponseSuccess = scholarshipGetFormAdminResponse200 & {
  headers: Headers;
};
export type scholarshipGetFormAdminResponse = scholarshipGetFormAdminResponseSuccess;

export const getScholarshipGetFormAdminUrl = (params: ScholarshipGetFormAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/scholarshipControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/scholarshipControl/getFormAdmin`;
};

export const scholarshipGetFormAdmin = async (
  params: ScholarshipGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<scholarshipGetFormAdminResponse> => {
  return openApiFetch<scholarshipGetFormAdminResponse>(getScholarshipGetFormAdminUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type readOwlGetAllResponse200 = {
  data: void;
  status: 200;
};

export type readOwlGetAllResponseSuccess = readOwlGetAllResponse200 & {
  headers: Headers;
};
export type readOwlGetAllResponse = readOwlGetAllResponseSuccess;

export const getReadOwlGetAllUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl`;
};

export const readOwlGetAll = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<readOwlGetAllResponse> => {
  return openApiFetch<readOwlGetAllResponse>(getReadOwlGetAllUrl(), {
    ...options,
    method: 'GET',
  });
};

export type readOwlSearchResponse200 = {
  data: ReadOwlSearch200Item[];
  status: 200;
};

export type readOwlSearchResponseSuccess = readOwlSearchResponse200 & {
  headers: Headers;
};
export type readOwlSearchResponse = readOwlSearchResponseSuccess;

export const getReadOwlSearchUrl = (params: ReadOwlSearchParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl/search?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl/search`;
};

export const readOwlSearch = async (
  params: ReadOwlSearchParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<readOwlSearchResponse> => {
  return openApiFetch<readOwlSearchResponse>(getReadOwlSearchUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type readOwlSearchByIdResponse200 = {
  data: string;
  status: 200;
};

export type readOwlSearchByIdResponseSuccess = readOwlSearchByIdResponse200 & {
  headers: Headers;
};
export type readOwlSearchByIdResponse = readOwlSearchByIdResponseSuccess;

export const getReadOwlSearchByIdUrl = (params: ReadOwlSearchByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl/searchById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl/searchById`;
};

export const readOwlSearchById = async (
  params: ReadOwlSearchByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<readOwlSearchByIdResponse> => {
  return openApiFetch<readOwlSearchByIdResponse>(getReadOwlSearchByIdUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type readOwlLngResponse200 = {
  data: string;
  status: 200;
};

export type readOwlLngResponseSuccess = readOwlLngResponse200 & {
  headers: Headers;
};
export type readOwlLngResponse = readOwlLngResponseSuccess;

export const getReadOwlLngUrl = (params: ReadOwlLngParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl/lng?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl/lng`;
};

export const readOwlLng = async (
  params: ReadOwlLngParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<readOwlLngResponse> => {
  return openApiFetch<readOwlLngResponse>(getReadOwlLngUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type readOwlGetByParentResponse200 = {
  data: ReadOwlGetByParent200Item[];
  status: 200;
};

export type readOwlGetByParentResponseSuccess = readOwlGetByParentResponse200 & {
  headers: Headers;
};
export type readOwlGetByParentResponse = readOwlGetByParentResponseSuccess;

export const getReadOwlGetByParentUrl = (params: ReadOwlGetByParentParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl/getByParent?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl/getByParent`;
};

export const readOwlGetByParent = async (
  params: ReadOwlGetByParentParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<readOwlGetByParentResponse> => {
  return openApiFetch<readOwlGetByParentResponse>(getReadOwlGetByParentUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type getArtFormListResponse200 = {
  data: GetArtFormList200;
  status: 200;
};

export type getArtFormListResponseSuccess = getArtFormListResponse200 & {
  headers: Headers;
};
export type getArtFormListResponse = getArtFormListResponseSuccess;

export const getGetArtFormListUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl/getArtFormList`;
};

export const getArtFormList = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<getArtFormListResponse> => {
  return openApiFetch<getArtFormListResponse>(getGetArtFormListUrl(), {
    ...options,
    method: 'GET',
  });
};

export type readOwlCreateCachedContentResponse200 = {
  data: ReadOwlCreateCachedContent200;
  status: 200;
};

export type readOwlCreateCachedContentResponseSuccess = readOwlCreateCachedContentResponse200 & {
  headers: Headers;
};
export type readOwlCreateCachedContentResponse = readOwlCreateCachedContentResponseSuccess;

export const getReadOwlCreateCachedContentUrl = (params: ReadOwlCreateCachedContentParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl/createCachedContent?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl/createCachedContent`;
};

export const readOwlCreateCachedContent = async (
  params: ReadOwlCreateCachedContentParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<readOwlCreateCachedContentResponse> => {
  return openApiFetch<readOwlCreateCachedContentResponse>(
    getReadOwlCreateCachedContentUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type readOwlCreateCachedContentNewResponse200 = {
  data: ReadOwlCreateCachedContentNew200;
  status: 200;
};

export type readOwlCreateCachedContentNewResponseSuccess =
  readOwlCreateCachedContentNewResponse200 & {
    headers: Headers;
  };
export type readOwlCreateCachedContentNewResponse = readOwlCreateCachedContentNewResponseSuccess;

export const getReadOwlCreateCachedContentNewUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl/createCachedContentNew`;
};

export const readOwlCreateCachedContentNew = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<readOwlCreateCachedContentNewResponse> => {
  return openApiFetch<readOwlCreateCachedContentNewResponse>(
    getReadOwlCreateCachedContentNewUrl(),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type readOwlClearResponse200 = {
  data: void;
  status: 200;
};

export type readOwlClearResponseSuccess = readOwlClearResponse200 & {
  headers: Headers;
};
export type readOwlClearResponse = readOwlClearResponseSuccess;

export const getReadOwlClearUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/readOwlControl/clear`;
};

export const readOwlClear = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<readOwlClearResponse> => {
  return openApiFetch<readOwlClearResponse>(getReadOwlClearUrl(), {
    ...options,
    method: 'GET',
  });
};

export type placeGetFormAdminResponse200 = {
  data: PlaceEditDto;
  status: 200;
};

export type placeGetFormAdminResponseSuccess = placeGetFormAdminResponse200 & {
  headers: Headers;
};
export type placeGetFormAdminResponse = placeGetFormAdminResponseSuccess;

export const getPlaceGetFormAdminUrl = (params: PlaceGetFormAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/placeControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/placeControl/getFormAdmin`;
};

export const placeGetFormAdmin = async (
  params: PlaceGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<placeGetFormAdminResponse> => {
  return openApiFetch<placeGetFormAdminResponse>(getPlaceGetFormAdminUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type placeDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type placeDeleteByIdResponseSuccess = placeDeleteByIdResponse200 & {
  headers: Headers;
};
export type placeDeleteByIdResponse = placeDeleteByIdResponseSuccess;

export const getPlaceDeleteByIdUrl = (params: PlaceDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/placeControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/placeControl/deleteById`;
};

export const placeDeleteById = async (
  params: PlaceDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<placeDeleteByIdResponse> => {
  return openApiFetch<placeDeleteByIdResponse>(getPlaceDeleteByIdUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type personalNameGetFormAdminResponse200 = {
  data: PersonalNameEditDto;
  status: 200;
};

export type personalNameGetFormAdminResponseSuccess = personalNameGetFormAdminResponse200 & {
  headers: Headers;
};
export type personalNameGetFormAdminResponse = personalNameGetFormAdminResponseSuccess;

export const getPersonalNameGetFormAdminUrl = (params: PersonalNameGetFormAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personalNameControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personalNameControl/getFormAdmin`;
};

export const personalNameGetFormAdmin = async (
  params: PersonalNameGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personalNameGetFormAdminResponse> => {
  return openApiFetch<personalNameGetFormAdminResponse>(getPersonalNameGetFormAdminUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type personalNameDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type personalNameDeleteByIdResponseSuccess = personalNameDeleteByIdResponse200 & {
  headers: Headers;
};
export type personalNameDeleteByIdResponse = personalNameDeleteByIdResponseSuccess;

export const getPersonalNameDeleteByIdUrl = (params: PersonalNameDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personalNameControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personalNameControl/deleteById`;
};

export const personalNameDeleteById = async (
  params: PersonalNameDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personalNameDeleteByIdResponse> => {
  return openApiFetch<personalNameDeleteByIdResponse>(getPersonalNameDeleteByIdUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type personGetLifeEventResponse200 = {
  data: WalkOfLifeDto[];
  status: 200;
};

export type personGetLifeEventResponseSuccess = personGetLifeEventResponse200 & {
  headers: Headers;
};
export type personGetLifeEventResponse = personGetLifeEventResponseSuccess;

export const getPersonGetLifeEventUrl = (params?: PersonGetLifeEventParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getLifeEvent?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getLifeEvent`;
};

export const personGetLifeEvent = async (
  params?: PersonGetLifeEventParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personGetLifeEventResponse> => {
  return openApiFetch<personGetLifeEventResponse>(getPersonGetLifeEventUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type personGetGraphPersonSubjectWordResponse200 = {
  data: PersonGetGraphPersonSubjectWord200;
  status: 200;
};

export type personGetGraphPersonSubjectWordResponseSuccess =
  personGetGraphPersonSubjectWordResponse200 & {
    headers: Headers;
  };
export type personGetGraphPersonSubjectWordResponse =
  personGetGraphPersonSubjectWordResponseSuccess;

export const getPersonGetGraphPersonSubjectWordUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getGraphPersonSubjectWord`;
};

export const personGetGraphPersonSubjectWord = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personGetGraphPersonSubjectWordResponse> => {
  return openApiFetch<personGetGraphPersonSubjectWordResponse>(
    getPersonGetGraphPersonSubjectWordUrl(),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type personGetFormTranslatorAdminResponse200 = {
  data: PersonTranslatorEditDto;
  status: 200;
};

export type personGetFormTranslatorAdminResponseSuccess =
  personGetFormTranslatorAdminResponse200 & {
    headers: Headers;
  };
export type personGetFormTranslatorAdminResponse = personGetFormTranslatorAdminResponseSuccess;

export const getPersonGetFormTranslatorAdminUrl = (params: PersonGetFormTranslatorAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getFormTranslatorAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getFormTranslatorAdmin`;
};

export const personGetFormTranslatorAdmin = async (
  params: PersonGetFormTranslatorAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personGetFormTranslatorAdminResponse> => {
  return openApiFetch<personGetFormTranslatorAdminResponse>(
    getPersonGetFormTranslatorAdminUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type personGetFormAdminResponse200 = {
  data: PersonEditDto;
  status: 200;
};

export type personGetFormAdminResponseSuccess = personGetFormAdminResponse200 & {
  headers: Headers;
};
export type personGetFormAdminResponse = personGetFormAdminResponseSuccess;

export const getPersonGetFormAdminUrl = (params: PersonGetFormAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getFormAdmin`;
};

export const personGetFormAdmin = async (
  params: PersonGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personGetFormAdminResponse> => {
  return openApiFetch<personGetFormAdminResponse>(getPersonGetFormAdminUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type personGetDataNewResponse200 = {
  data: PersonDataDto;
  status: 200;
};

export type personGetDataNewResponseSuccess = personGetDataNewResponse200 & {
  headers: Headers;
};
export type personGetDataNewResponse = personGetDataNewResponseSuccess;

export const getPersonGetDataNewUrl = (params?: PersonGetDataNewParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getData?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getData`;
};

export const personGetDataNew = async (
  params?: PersonGetDataNewParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personGetDataNewResponse> => {
  return openApiFetch<personGetDataNewResponse>(getPersonGetDataNewUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type personGetDataWithRecommendationResponse200 = {
  data: PersonDataDto;
  status: 200;
};

export type personGetDataWithRecommendationResponseSuccess =
  personGetDataWithRecommendationResponse200 & {
    headers: Headers;
  };
export type personGetDataWithRecommendationResponse =
  personGetDataWithRecommendationResponseSuccess;

export const getPersonGetDataWithRecommendationUrl = (
  params?: PersonGetDataWithRecommendationParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getDataWithRecommendation?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getDataWithRecommendation`;
};

export const personGetDataWithRecommendation = async (
  params?: PersonGetDataWithRecommendationParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personGetDataWithRecommendationResponse> => {
  return openApiFetch<personGetDataWithRecommendationResponse>(
    getPersonGetDataWithRecommendationUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type personGetCVResponse200 = {
  data: string;
  status: 200;
};

export type personGetCVResponseSuccess = personGetCVResponse200 & {
  headers: Headers;
};
export type personGetCVResponse = personGetCVResponseSuccess;

export const getPersonGetCVUrl = (params: PersonGetCVParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getCV?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getCV`;
};

export const personGetCV = async (
  params: PersonGetCVParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personGetCVResponse> => {
  return openApiFetch<personGetCVResponse>(getPersonGetCVUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type personGetBirthdayInfoResponse200 = {
  data: PersonGetBirthdayInfo200;
  status: 200;
};

export type personGetBirthdayInfoResponseSuccess = personGetBirthdayInfoResponse200 & {
  headers: Headers;
};
export type personGetBirthdayInfoResponse = personGetBirthdayInfoResponseSuccess;

export const getPersonGetBirthdayInfoUrl = (params: PersonGetBirthdayInfoParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getBirthdayInfo?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/getBirthdayInfo`;
};

export const personGetBirthdayInfo = async (
  params: PersonGetBirthdayInfoParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personGetBirthdayInfoResponse> => {
  return openApiFetch<personGetBirthdayInfoResponse>(getPersonGetBirthdayInfoUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type personAwardingInstanceGetFormAdminResponse200 = {
  data: PersonAwardingInstanceEditDto;
  status: 200;
};

export type personAwardingInstanceGetFormAdminResponseSuccess =
  personAwardingInstanceGetFormAdminResponse200 & {
    headers: Headers;
  };
export type personAwardingInstanceGetFormAdminResponse =
  personAwardingInstanceGetFormAdminResponseSuccess;

export const getPersonAwardingInstanceGetFormAdminUrl = (
  params: PersonAwardingInstanceGetFormAdminParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personAwardingInstanceControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personAwardingInstanceControl/getFormAdmin`;
};

export const personAwardingInstanceGetFormAdmin = async (
  params: PersonAwardingInstanceGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personAwardingInstanceGetFormAdminResponse> => {
  return openApiFetch<personAwardingInstanceGetFormAdminResponse>(
    getPersonAwardingInstanceGetFormAdminUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type personAwardingInstanceGetAwardDetailsResponse200 = {
  data: PersonAwardingInstanceGetAwardDetails200Item[];
  status: 200;
};

export type personAwardingInstanceGetAwardDetailsResponseSuccess =
  personAwardingInstanceGetAwardDetailsResponse200 & {
    headers: Headers;
  };
export type personAwardingInstanceGetAwardDetailsResponse =
  personAwardingInstanceGetAwardDetailsResponseSuccess;

export const getPersonAwardingInstanceGetAwardDetailsUrl = (
  params?: PersonAwardingInstanceGetAwardDetailsParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personAwardingInstanceControl/getAwardDetails?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personAwardingInstanceControl/getAwardDetails`;
};

export const personAwardingInstanceGetAwardDetails = async (
  params?: PersonAwardingInstanceGetAwardDetailsParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personAwardingInstanceGetAwardDetailsResponse> => {
  return openApiFetch<personAwardingInstanceGetAwardDetailsResponse>(
    getPersonAwardingInstanceGetAwardDetailsUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type personAwardingInstanceDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type personAwardingInstanceDeleteByIdResponseSuccess =
  personAwardingInstanceDeleteByIdResponse200 & {
    headers: Headers;
  };
export type personAwardingInstanceDeleteByIdResponse =
  personAwardingInstanceDeleteByIdResponseSuccess;

export const getPersonAwardingInstanceDeleteByIdUrl = (
  params: PersonAwardingInstanceDeleteByIdParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personAwardingInstanceControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personAwardingInstanceControl/deleteById`;
};

export const personAwardingInstanceDeleteById = async (
  params: PersonAwardingInstanceDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personAwardingInstanceDeleteByIdResponse> => {
  return openApiFetch<personAwardingInstanceDeleteByIdResponse>(
    getPersonAwardingInstanceDeleteByIdUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type newsGetFormAdminResponse200 = {
  data: NewsEditDto;
  status: 200;
};

export type newsGetFormAdminResponseSuccess = newsGetFormAdminResponse200 & {
  headers: Headers;
};
export type newsGetFormAdminResponse = newsGetFormAdminResponseSuccess;

export const getNewsGetFormAdminUrl = (params: NewsGetFormAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/newsControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/newsControl/getFormAdmin`;
};

export const newsGetFormAdmin = async (
  params: NewsGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<newsGetFormAdminResponse> => {
  return openApiFetch<newsGetFormAdminResponse>(getNewsGetFormAdminUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type newsGetAllNewsResponse200 = {
  data: NewsEditDto[];
  status: 200;
};

export type newsGetAllNewsResponseSuccess = newsGetAllNewsResponse200 & {
  headers: Headers;
};
export type newsGetAllNewsResponse = newsGetAllNewsResponseSuccess;

export const getNewsGetAllNewsUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/newsControl/getAllNews`;
};

export const newsGetAllNews = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<newsGetAllNewsResponse> => {
  return openApiFetch<newsGetAllNewsResponse>(getNewsGetAllNewsUrl(), {
    ...options,
    method: 'GET',
  });
};

export type newsGetActualsResponse200 = {
  data: NewsActualOutDto[];
  status: 200;
};

export type newsGetActualsResponseSuccess = newsGetActualsResponse200 & {
  headers: Headers;
};
export type newsGetActualsResponse = newsGetActualsResponseSuccess;

export const getNewsGetActualsUrl = (params: NewsGetActualsParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/newsControl/getActuals?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/newsControl/getActuals`;
};

export const newsGetActuals = async (
  params: NewsGetActualsParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<newsGetActualsResponse> => {
  return openApiFetch<newsGetActualsResponse>(getNewsGetActualsUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type mediaContentGetFormAdminResponse200 = {
  data: MediaContentEditDto;
  status: 200;
};

export type mediaContentGetFormAdminResponseSuccess = mediaContentGetFormAdminResponse200 & {
  headers: Headers;
};
export type mediaContentGetFormAdminResponse = mediaContentGetFormAdminResponseSuccess;

export const getMediaContentGetFormAdminUrl = (params: MediaContentGetFormAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/mediaContentControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/mediaContentControl/getFormAdmin`;
};

export const mediaContentGetFormAdmin = async (
  params: MediaContentGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<mediaContentGetFormAdminResponse> => {
  return openApiFetch<mediaContentGetFormAdminResponse>(getMediaContentGetFormAdminUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type authGetLoggedInUserResponse200 = {
  data: AuthUserDto;
  status: 200;
};

export type authGetLoggedInUserResponseSuccess = authGetLoggedInUserResponse200 & {
  headers: Headers;
};
export type authGetLoggedInUserResponse = authGetLoggedInUserResponseSuccess;

export const getAuthGetLoggedInUserUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/me`;
};

export const authGetLoggedInUser = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<authGetLoggedInUserResponse> => {
  return openApiFetch<authGetLoggedInUserResponse>(getAuthGetLoggedInUserUrl(), {
    ...options,
    method: 'GET',
  });
};

export type instituteReduxGetFormAdminResponse200 = {
  data: InstituteReduxEditDto;
  status: 200;
};

export type instituteReduxGetFormAdminResponseSuccess = instituteReduxGetFormAdminResponse200 & {
  headers: Headers;
};
export type instituteReduxGetFormAdminResponse = instituteReduxGetFormAdminResponseSuccess;

export const getInstituteReduxGetFormAdminUrl = (params: InstituteReduxGetFormAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteReduxControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteReduxControl/getFormAdmin`;
};

export const instituteReduxGetFormAdmin = async (
  params: InstituteReduxGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<instituteReduxGetFormAdminResponse> => {
  return openApiFetch<instituteReduxGetFormAdminResponse>(
    getInstituteReduxGetFormAdminUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type instituteReduxGetComboListResponse200 = {
  data: InstituteReduxGetComboList200Item[];
  status: 200;
};

export type instituteReduxGetComboListResponseSuccess = instituteReduxGetComboListResponse200 & {
  headers: Headers;
};
export type instituteReduxGetComboListResponse = instituteReduxGetComboListResponseSuccess;

export const getInstituteReduxGetComboListUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteReduxControl/getComboList`;
};

export const instituteReduxGetComboList = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<instituteReduxGetComboListResponse> => {
  return openApiFetch<instituteReduxGetComboListResponse>(getInstituteReduxGetComboListUrl(), {
    ...options,
    method: 'GET',
  });
};

export type instituteReduxDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type instituteReduxDeleteByIdResponseSuccess = instituteReduxDeleteByIdResponse200 & {
  headers: Headers;
};
export type instituteReduxDeleteByIdResponse = instituteReduxDeleteByIdResponseSuccess;

export const getInstituteReduxDeleteByIdUrl = (params: InstituteReduxDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteReduxControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteReduxControl/deleteById`;
};

export const instituteReduxDeleteById = async (
  params: InstituteReduxDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<instituteReduxDeleteByIdResponse> => {
  return openApiFetch<instituteReduxDeleteByIdResponse>(getInstituteReduxDeleteByIdUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type institutePredSuccGetFormAdminResponse200 = {
  data: InstitutePredSuccEditDto;
  status: 200;
};

export type institutePredSuccGetFormAdminResponseSuccess =
  institutePredSuccGetFormAdminResponse200 & {
    headers: Headers;
  };
export type institutePredSuccGetFormAdminResponse = institutePredSuccGetFormAdminResponseSuccess;

export const getInstitutePredSuccGetFormAdminUrl = (
  params: InstitutePredSuccGetFormAdminParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/institutePredSuccControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/institutePredSuccControl/getFormAdmin`;
};

export const institutePredSuccGetFormAdmin = async (
  params: InstitutePredSuccGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<institutePredSuccGetFormAdminResponse> => {
  return openApiFetch<institutePredSuccGetFormAdminResponse>(
    getInstitutePredSuccGetFormAdminUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type instituteGetFormAdminResponse200 = {
  data: InstituteEditDto;
  status: 200;
};

export type instituteGetFormAdminResponseSuccess = instituteGetFormAdminResponse200 & {
  headers: Headers;
};
export type instituteGetFormAdminResponse = instituteGetFormAdminResponseSuccess;

export const getInstituteGetFormAdminUrl = (params: InstituteGetFormAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteControl/getFormAdmin`;
};

export const instituteGetFormAdmin = async (
  params: InstituteGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<instituteGetFormAdminResponse> => {
  return openApiFetch<instituteGetFormAdminResponse>(getInstituteGetFormAdminUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type instituteDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type instituteDeleteByIdResponseSuccess = instituteDeleteByIdResponse200 & {
  headers: Headers;
};
export type instituteDeleteByIdResponse = instituteDeleteByIdResponseSuccess;

export const getInstituteDeleteByIdUrl = (params: InstituteDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/instituteControl/deleteById`;
};

export const instituteDeleteById = async (
  params: InstituteDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<instituteDeleteByIdResponse> => {
  return openApiFetch<instituteDeleteByIdResponse>(getInstituteDeleteByIdUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type imageRepositoryDeleteFileResponse200 = {
  data: boolean;
  status: 200;
};

export type imageRepositoryDeleteFileResponseSuccess = imageRepositoryDeleteFileResponse200 & {
  headers: Headers;
};
export type imageRepositoryDeleteFileResponse = imageRepositoryDeleteFileResponseSuccess;

export const getImageRepositoryDeleteFileUrl = (params?: ImageRepositoryDeleteFileParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/imageRepository/deleteFile?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/imageRepository/deleteFile`;
};

export const imageRepositoryDeleteFile = async (
  params?: ImageRepositoryDeleteFileParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<imageRepositoryDeleteFileResponse> => {
  return openApiFetch<imageRepositoryDeleteFileResponse>(getImageRepositoryDeleteFileUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type eventExternalUploadGetEventComboResponse200 = {
  data: NamedDto[];
  status: 200;
};

export type eventExternalUploadGetEventComboResponseSuccess =
  eventExternalUploadGetEventComboResponse200 & {
    headers: Headers;
  };
export type eventExternalUploadGetEventComboResponse =
  eventExternalUploadGetEventComboResponseSuccess;

export const getEventExternalUploadGetEventComboUrl = (
  params: EventExternalUploadGetEventComboParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/eventExternalUploadControl/getEventCombo?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/eventExternalUploadControl/getEventCombo`;
};

export const eventExternalUploadGetEventCombo = async (
  params: EventExternalUploadGetEventComboParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<eventExternalUploadGetEventComboResponse> => {
  return openApiFetch<eventExternalUploadGetEventComboResponse>(
    getEventExternalUploadGetEventComboUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type eventExternalUploadGetComboResponse200 = {
  data: NamedDto[];
  status: 200;
};

export type eventExternalUploadGetComboResponseSuccess = eventExternalUploadGetComboResponse200 & {
  headers: Headers;
};
export type eventExternalUploadGetComboResponse = eventExternalUploadGetComboResponseSuccess;

export const getEventExternalUploadGetComboUrl = (params: EventExternalUploadGetComboParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/eventExternalUploadControl/getCombo?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/eventExternalUploadControl/getCombo`;
};

export const eventExternalUploadGetCombo = async (
  params: EventExternalUploadGetComboParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<eventExternalUploadGetComboResponse> => {
  return openApiFetch<eventExternalUploadGetComboResponse>(
    getEventExternalUploadGetComboUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type culturalEntityRelationshipGetFormAdminResponse200 = {
  data: CulturalEntityRelationshipEditDto;
  status: 200;
};

export type culturalEntityRelationshipGetFormAdminResponseSuccess =
  culturalEntityRelationshipGetFormAdminResponse200 & {
    headers: Headers;
  };
export type culturalEntityRelationshipGetFormAdminResponse =
  culturalEntityRelationshipGetFormAdminResponseSuccess;

export const getCulturalEntityRelationshipGetFormAdminUrl = (
  params: CulturalEntityRelationshipGetFormAdminParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityRelationshipControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityRelationshipControl/getFormAdmin`;
};

export const culturalEntityRelationshipGetFormAdmin = async (
  params: CulturalEntityRelationshipGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityRelationshipGetFormAdminResponse> => {
  return openApiFetch<culturalEntityRelationshipGetFormAdminResponse>(
    getCulturalEntityRelationshipGetFormAdminUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type culturalEntityTestResponse200 = {
  data: void;
  status: 200;
};

export type culturalEntityTestResponseSuccess = culturalEntityTestResponse200 & {
  headers: Headers;
};
export type culturalEntityTestResponse = culturalEntityTestResponseSuccess;

export const getCulturalEntityTestUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/test`;
};

export const culturalEntityTest = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityTestResponse> => {
  return openApiFetch<culturalEntityTestResponse>(getCulturalEntityTestUrl(), {
    ...options,
    method: 'GET',
  });
};

export type culturalEntitySearchResponse200 = {
  data: CulturalEntitySearch200;
  status: 200;
};

export type culturalEntitySearchResponseSuccess = culturalEntitySearchResponse200 & {
  headers: Headers;
};
export type culturalEntitySearchResponse = culturalEntitySearchResponseSuccess;

export const getCulturalEntitySearchUrl = (params: CulturalEntitySearchParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/search?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/search`;
};

export const culturalEntitySearch = async (
  params: CulturalEntitySearchParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntitySearchResponse> => {
  return openApiFetch<culturalEntitySearchResponse>(getCulturalEntitySearchUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type culturalEntityGetFormAdminResponse200 = {
  data: CulturalEntityDto;
  status: 200;
};

export type culturalEntityGetFormAdminResponseSuccess = culturalEntityGetFormAdminResponse200 & {
  headers: Headers;
};
export type culturalEntityGetFormAdminResponse = culturalEntityGetFormAdminResponseSuccess;

export const getCulturalEntityGetFormAdminUrl = (params: CulturalEntityGetFormAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/getFormAdmin`;
};

export const culturalEntityGetFormAdmin = async (
  params: CulturalEntityGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityGetFormAdminResponse> => {
  return openApiFetch<culturalEntityGetFormAdminResponse>(
    getCulturalEntityGetFormAdminUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type culturalEntityGetFilteredListResponse200 = {
  data: ContentListDto[];
  status: 200;
};

export type culturalEntityGetFilteredListResponseSuccess =
  culturalEntityGetFilteredListResponse200 & {
    headers: Headers;
  };
export type culturalEntityGetFilteredListResponse = culturalEntityGetFilteredListResponseSuccess;

export const getCulturalEntityGetFilteredListUrl = (
  params?: CulturalEntityGetFilteredListParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/getFilteredList?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/getFilteredList`;
};

export const culturalEntityGetFilteredList = async (
  params?: CulturalEntityGetFilteredListParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityGetFilteredListResponse> => {
  return openApiFetch<culturalEntityGetFilteredListResponse>(
    getCulturalEntityGetFilteredListUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type culturalEntityGetEventsResponse200 = {
  data: EventWorksheetOutDto[];
  status: 200;
};

export type culturalEntityGetEventsResponseSuccess = culturalEntityGetEventsResponse200 & {
  headers: Headers;
};
export type culturalEntityGetEventsResponse = culturalEntityGetEventsResponseSuccess;

export const getCulturalEntityGetEventsUrl = (params: CulturalEntityGetEventsParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/getEvents?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/getEvents`;
};

export const culturalEntityGetEvents = async (
  params: CulturalEntityGetEventsParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityGetEventsResponse> => {
  return openApiFetch<culturalEntityGetEventsResponse>(getCulturalEntityGetEventsUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type culturalEntityGetDataResponse200 = {
  data: ContentDto;
  status: 200;
};

export type culturalEntityGetDataResponseSuccess = culturalEntityGetDataResponse200 & {
  headers: Headers;
};
export type culturalEntityGetDataResponse = culturalEntityGetDataResponseSuccess;

export const getCulturalEntityGetDataUrl = (params?: CulturalEntityGetDataParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/getData?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/getData`;
};

export const culturalEntityGetData = async (
  params?: CulturalEntityGetDataParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityGetDataResponse> => {
  return openApiFetch<culturalEntityGetDataResponse>(getCulturalEntityGetDataUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type culturalEntityCheckRedisResponse200 = {
  data: void;
  status: 200;
};

export type culturalEntityCheckRedisResponseSuccess = culturalEntityCheckRedisResponse200 & {
  headers: Headers;
};
export type culturalEntityCheckRedisResponse = culturalEntityCheckRedisResponseSuccess;

export const getCulturalEntityCheckRedisUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/checkRedis`;
};

export const culturalEntityCheckRedis = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityCheckRedisResponse> => {
  return openApiFetch<culturalEntityCheckRedisResponse>(getCulturalEntityCheckRedisUrl(), {
    ...options,
    method: 'GET',
  });
};

export type authGetCsrfTokenResponse200 = {
  data: CsrfToken;
  status: 200;
};

export type authGetCsrfTokenResponseSuccess = authGetCsrfTokenResponse200 & {
  headers: Headers;
};
export type authGetCsrfTokenResponse = authGetCsrfTokenResponseSuccess;

export const getAuthGetCsrfTokenUrl = (params: AuthGetCsrfTokenParams) => {
  const normalizedParams = new URLSearchParams();
  const formObjectParameters = new Map<string, string>([['csrfToken', 'flatten']]);

  Object.entries(params || {}).forEach(([key, value]) => {
    if (
      typeof value === 'object' &&
      value !== null &&
      !Array.isArray(value) &&
      !(value instanceof Date) &&
      formObjectParameters.has(key)
    ) {
      const commaParts: string[] = [];
      Object.entries(value).forEach(([subKey, subValue]) => {
        const items = (Array.isArray(subValue) ? subValue : [subValue])
          .filter((v) => v !== undefined)
          .map((v) =>
            v === null
              ? 'null'
              : v instanceof Date
                ? v.toISOString()
                : typeof v === 'object'
                  ? JSON.stringify(v)
                  : String(v)
          );
        if (formObjectParameters.get(key) === 'flatten') {
          items.forEach((item) => normalizedParams.append(subKey, item));
        } else if (items.length > 0) {
          commaParts.push(subKey, ...items);
        }
      });
      if (commaParts.length > 0) {
        normalizedParams.append(key, commaParts.join(','));
      }
      return;
    }

    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/csrf?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/csrf`;
};

export const authGetCsrfToken = async (
  params: AuthGetCsrfTokenParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<authGetCsrfTokenResponse> => {
  return openApiFetch<authGetCsrfTokenResponse>(getAuthGetCsrfTokenUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type contentCollectionGetFormAdminResponse200 = {
  data: ContentCollectionEditDto;
  status: 200;
};

export type contentCollectionGetFormAdminResponseSuccess =
  contentCollectionGetFormAdminResponse200 & {
    headers: Headers;
  };
export type contentCollectionGetFormAdminResponse = contentCollectionGetFormAdminResponseSuccess;

export const getContentCollectionGetFormAdminUrl = (
  params: ContentCollectionGetFormAdminParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/contentCollectionControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/contentCollectionControl/getFormAdmin`;
};

export const contentCollectionGetFormAdmin = async (
  params: ContentCollectionGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<contentCollectionGetFormAdminResponse> => {
  return openApiFetch<contentCollectionGetFormAdminResponse>(
    getContentCollectionGetFormAdminUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type contentCollectionGetCollectionResponse200 = {
  data: ContentCollectionOutputDto;
  status: 200;
};

export type contentCollectionGetCollectionResponseSuccess =
  contentCollectionGetCollectionResponse200 & {
    headers: Headers;
  };
export type contentCollectionGetCollectionResponse = contentCollectionGetCollectionResponseSuccess;

export const getContentCollectionGetCollectionUrl = (
  params: ContentCollectionGetCollectionParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/contentCollectionControl/getCollection?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/contentCollectionControl/getCollection`;
};

export const contentCollectionGetCollection = async (
  params: ContentCollectionGetCollectionParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<contentCollectionGetCollectionResponse> => {
  return openApiFetch<contentCollectionGetCollectionResponse>(
    getContentCollectionGetCollectionUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type contentCollectionDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type contentCollectionDeleteByIdResponseSuccess = contentCollectionDeleteByIdResponse200 & {
  headers: Headers;
};
export type contentCollectionDeleteByIdResponse = contentCollectionDeleteByIdResponseSuccess;

export const getContentCollectionDeleteByIdUrl = (params: ContentCollectionDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/contentCollectionControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/contentCollectionControl/deleteById`;
};

export const contentCollectionDeleteById = async (
  params: ContentCollectionDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<contentCollectionDeleteByIdResponse> => {
  return openApiFetch<contentCollectionDeleteByIdResponse>(
    getContentCollectionDeleteByIdUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type comboUploadHelperGetProfessionResponse200 = {
  data: ComboUploadHelperGetProfession200;
  status: 200;
};

export type comboUploadHelperGetProfessionResponseSuccess =
  comboUploadHelperGetProfessionResponse200 & {
    headers: Headers;
  };
export type comboUploadHelperGetProfessionResponse = comboUploadHelperGetProfessionResponseSuccess;

export const getComboUploadHelperGetProfessionUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/comboUploadHelperControl/getProfession`;
};

export const comboUploadHelperGetProfession = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<comboUploadHelperGetProfessionResponse> => {
  return openApiFetch<comboUploadHelperGetProfessionResponse>(
    getComboUploadHelperGetProfessionUrl(),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type comboUploadHelperGetPersonResponse200 = {
  data: ComboUploadHelperGetPerson200;
  status: 200;
};

export type comboUploadHelperGetPersonResponseSuccess = comboUploadHelperGetPersonResponse200 & {
  headers: Headers;
};
export type comboUploadHelperGetPersonResponse = comboUploadHelperGetPersonResponseSuccess;

export const getComboUploadHelperGetPersonUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/comboUploadHelperControl/getPerson`;
};

export const comboUploadHelperGetPerson = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<comboUploadHelperGetPersonResponse> => {
  return openApiFetch<comboUploadHelperGetPersonResponse>(getComboUploadHelperGetPersonUrl(), {
    ...options,
    method: 'GET',
  });
};

export type comboUploadHelperGetMetaByIdResponse200 = {
  data: ComboUploadHelperGetMetaById200;
  status: 200;
};

export type comboUploadHelperGetMetaByIdResponseSuccess =
  comboUploadHelperGetMetaByIdResponse200 & {
    headers: Headers;
  };
export type comboUploadHelperGetMetaByIdResponse = comboUploadHelperGetMetaByIdResponseSuccess;

export const getComboUploadHelperGetMetaByIdUrl = (params: ComboUploadHelperGetMetaByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/comboUploadHelperControl/getMetaById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/comboUploadHelperControl/getMetaById`;
};

export const comboUploadHelperGetMetaById = async (
  params: ComboUploadHelperGetMetaByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<comboUploadHelperGetMetaByIdResponse> => {
  return openApiFetch<comboUploadHelperGetMetaByIdResponse>(
    getComboUploadHelperGetMetaByIdUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type comboUploadHelperGetInstituteResponse200 = {
  data: ComboUploadHelperGetInstitute200;
  status: 200;
};

export type comboUploadHelperGetInstituteResponseSuccess =
  comboUploadHelperGetInstituteResponse200 & {
    headers: Headers;
  };
export type comboUploadHelperGetInstituteResponse = comboUploadHelperGetInstituteResponseSuccess;

export const getComboUploadHelperGetInstituteUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/comboUploadHelperControl/getInstitute`;
};

export const comboUploadHelperGetInstitute = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<comboUploadHelperGetInstituteResponse> => {
  return openApiFetch<comboUploadHelperGetInstituteResponse>(
    getComboUploadHelperGetInstituteUrl(),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type comboUploadHelperGetInstituteReduxResponse200 = {
  data: ComboUploadHelperGetInstituteRedux200;
  status: 200;
};

export type comboUploadHelperGetInstituteReduxResponseSuccess =
  comboUploadHelperGetInstituteReduxResponse200 & {
    headers: Headers;
  };
export type comboUploadHelperGetInstituteReduxResponse =
  comboUploadHelperGetInstituteReduxResponseSuccess;

export const getComboUploadHelperGetInstituteReduxUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/comboUploadHelperControl/getInstituteRedux`;
};

export const comboUploadHelperGetInstituteRedux = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<comboUploadHelperGetInstituteReduxResponse> => {
  return openApiFetch<comboUploadHelperGetInstituteReduxResponse>(
    getComboUploadHelperGetInstituteReduxUrl(),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type comboUploadHelperGetEventWorksheetResponse200 = {
  data: ComboUploadHelperGetEventWorksheet200;
  status: 200;
};

export type comboUploadHelperGetEventWorksheetResponseSuccess =
  comboUploadHelperGetEventWorksheetResponse200 & {
    headers: Headers;
  };
export type comboUploadHelperGetEventWorksheetResponse =
  comboUploadHelperGetEventWorksheetResponseSuccess;

export const getComboUploadHelperGetEventWorksheetUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/comboUploadHelperControl/getEventWorksheet`;
};

export const comboUploadHelperGetEventWorksheet = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<comboUploadHelperGetEventWorksheetResponse> => {
  return openApiFetch<comboUploadHelperGetEventWorksheetResponse>(
    getComboUploadHelperGetEventWorksheetUrl(),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type comboUploadHelperGetDateTypeResponse200 = {
  data: ComboUploadHelperGetDateType200;
  status: 200;
};

export type comboUploadHelperGetDateTypeResponseSuccess =
  comboUploadHelperGetDateTypeResponse200 & {
    headers: Headers;
  };
export type comboUploadHelperGetDateTypeResponse = comboUploadHelperGetDateTypeResponseSuccess;

export const getComboUploadHelperGetDateTypeUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/comboUploadHelperControl/getDateType`;
};

export const comboUploadHelperGetDateType = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<comboUploadHelperGetDateTypeResponse> => {
  return openApiFetch<comboUploadHelperGetDateTypeResponse>(getComboUploadHelperGetDateTypeUrl(), {
    ...options,
    method: 'GET',
  });
};

export type comboUploadHelperGetCulturalEntityResponse200 = {
  data: ComboUploadHelperGetCulturalEntity200;
  status: 200;
};

export type comboUploadHelperGetCulturalEntityResponseSuccess =
  comboUploadHelperGetCulturalEntityResponse200 & {
    headers: Headers;
  };
export type comboUploadHelperGetCulturalEntityResponse =
  comboUploadHelperGetCulturalEntityResponseSuccess;

export const getComboUploadHelperGetCulturalEntityUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/comboUploadHelperControl/getCulturalEntity`;
};

export const comboUploadHelperGetCulturalEntity = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<comboUploadHelperGetCulturalEntityResponse> => {
  return openApiFetch<comboUploadHelperGetCulturalEntityResponse>(
    getComboUploadHelperGetCulturalEntityUrl(),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type comboUploadHelperGetAwardingInstanceResponse200 = {
  data: ComboUploadHelperGetAwardingInstance200;
  status: 200;
};

export type comboUploadHelperGetAwardingInstanceResponseSuccess =
  comboUploadHelperGetAwardingInstanceResponse200 & {
    headers: Headers;
  };
export type comboUploadHelperGetAwardingInstanceResponse =
  comboUploadHelperGetAwardingInstanceResponseSuccess;

export const getComboUploadHelperGetAwardingInstanceUrl = () => {
  return `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/comboUploadHelperControl/getAwardingInstance`;
};

export const comboUploadHelperGetAwardingInstance = async (
  options?: Parameters<typeof openApiFetch>[1]
): Promise<comboUploadHelperGetAwardingInstanceResponse> => {
  return openApiFetch<comboUploadHelperGetAwardingInstanceResponse>(
    getComboUploadHelperGetAwardingInstanceUrl(),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type awardingPredSuccGetFormAdminResponse200 = {
  data: AwardingPredSuccEditDto;
  status: 200;
};

export type awardingPredSuccGetFormAdminResponseSuccess =
  awardingPredSuccGetFormAdminResponse200 & {
    headers: Headers;
  };
export type awardingPredSuccGetFormAdminResponse = awardingPredSuccGetFormAdminResponseSuccess;

export const getAwardingPredSuccGetFormAdminUrl = (params: AwardingPredSuccGetFormAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingPredSuccControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingPredSuccControl/getFormAdmin`;
};

export const awardingPredSuccGetFormAdmin = async (
  params: AwardingPredSuccGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<awardingPredSuccGetFormAdminResponse> => {
  return openApiFetch<awardingPredSuccGetFormAdminResponse>(
    getAwardingPredSuccGetFormAdminUrl(params),
    {
      ...options,
      method: 'GET',
    }
  );
};

export type awardingGetFormAdminResponse200 = {
  data: AwardingEditDto;
  status: 200;
};

export type awardingGetFormAdminResponseSuccess = awardingGetFormAdminResponse200 & {
  headers: Headers;
};
export type awardingGetFormAdminResponse = awardingGetFormAdminResponseSuccess;

export const getAwardingGetFormAdminUrl = (params: AwardingGetFormAdminParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingControl/getFormAdmin?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingControl/getFormAdmin`;
};

export const awardingGetFormAdmin = async (
  params: AwardingGetFormAdminParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<awardingGetFormAdminResponse> => {
  return openApiFetch<awardingGetFormAdminResponse>(getAwardingGetFormAdminUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type awardingDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type awardingDeleteByIdResponseSuccess = awardingDeleteByIdResponse200 & {
  headers: Headers;
};
export type awardingDeleteByIdResponse = awardingDeleteByIdResponseSuccess;

export const getAwardingDeleteByIdUrl = (params: AwardingDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingControl/deleteById`;
};

export const awardingDeleteById = async (
  params: AwardingDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<awardingDeleteByIdResponse> => {
  return openApiFetch<awardingDeleteByIdResponse>(getAwardingDeleteByIdUrl(params), {
    ...options,
    method: 'GET',
  });
};

export type websitePropertiesDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type websitePropertiesDeleteByIdResponseSuccess = websitePropertiesDeleteByIdResponse200 & {
  headers: Headers;
};
export type websitePropertiesDeleteByIdResponse = websitePropertiesDeleteByIdResponseSuccess;

export const getWebsitePropertiesDeleteByIdUrl = (params: WebsitePropertiesDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/websitePropertiesControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/websitePropertiesControl/deleteById`;
};

export const websitePropertiesDeleteById = async (
  params: WebsitePropertiesDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<websitePropertiesDeleteByIdResponse> => {
  return openApiFetch<websitePropertiesDeleteByIdResponse>(
    getWebsitePropertiesDeleteByIdUrl(params),
    {
      ...options,
      method: 'DELETE',
    }
  );
};

export type websitePropertiesDeleteById1Response200 = {
  data: boolean;
  status: 200;
};

export type websitePropertiesDeleteById1ResponseSuccess =
  websitePropertiesDeleteById1Response200 & {
    headers: Headers;
  };
export type websitePropertiesDeleteById1Response = websitePropertiesDeleteById1ResponseSuccess;

export const getWebsitePropertiesDeleteById1Url = (params: WebsitePropertiesDeleteById1Params) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/mmaController/websitePropertiesControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/mmaController/websitePropertiesControl/deleteById`;
};

export const websitePropertiesDeleteById1 = async (
  params: WebsitePropertiesDeleteById1Params,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<websitePropertiesDeleteById1Response> => {
  return openApiFetch<websitePropertiesDeleteById1Response>(
    getWebsitePropertiesDeleteById1Url(params),
    {
      ...options,
      method: 'DELETE',
    }
  );
};

export type videoReferencePlayListDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type videoReferencePlayListDeleteByIdResponseSuccess =
  videoReferencePlayListDeleteByIdResponse200 & {
    headers: Headers;
  };
export type videoReferencePlayListDeleteByIdResponse =
  videoReferencePlayListDeleteByIdResponseSuccess;

export const getVideoReferencePlayListDeleteByIdUrl = (
  params: VideoReferencePlayListDeleteByIdParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferencePlayListControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/videoReferencePlayListControl/deleteById`;
};

export const videoReferencePlayListDeleteById = async (
  params: VideoReferencePlayListDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<videoReferencePlayListDeleteByIdResponse> => {
  return openApiFetch<videoReferencePlayListDeleteByIdResponse>(
    getVideoReferencePlayListDeleteByIdUrl(params),
    {
      ...options,
      method: 'DELETE',
    }
  );
};

export type userSettingsDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type userSettingsDeleteByIdResponseSuccess = userSettingsDeleteByIdResponse200 & {
  headers: Headers;
};
export type userSettingsDeleteByIdResponse = userSettingsDeleteByIdResponseSuccess;

export const getUserSettingsDeleteByIdUrl = (params: UserSettingsDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/userSettingsControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/userSettingsControl/deleteById`;
};

export const userSettingsDeleteById = async (
  params: UserSettingsDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<userSettingsDeleteByIdResponse> => {
  return openApiFetch<userSettingsDeleteByIdResponse>(getUserSettingsDeleteByIdUrl(params), {
    ...options,
    method: 'DELETE',
  });
};

export type scholarshipDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type scholarshipDeleteByIdResponseSuccess = scholarshipDeleteByIdResponse200 & {
  headers: Headers;
};
export type scholarshipDeleteByIdResponse = scholarshipDeleteByIdResponseSuccess;

export const getScholarshipDeleteByIdUrl = (params: ScholarshipDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/scholarshipControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/scholarshipControl/deleteById`;
};

export const scholarshipDeleteById = async (
  params: ScholarshipDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<scholarshipDeleteByIdResponse> => {
  return openApiFetch<scholarshipDeleteByIdResponse>(getScholarshipDeleteByIdUrl(params), {
    ...options,
    method: 'DELETE',
  });
};

export type personDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type personDeleteByIdResponseSuccess = personDeleteByIdResponse200 & {
  headers: Headers;
};
export type personDeleteByIdResponse = personDeleteByIdResponseSuccess;

export const getPersonDeleteByIdUrl = (params: PersonDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/personControl/deleteById`;
};

export const personDeleteById = async (
  params: PersonDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<personDeleteByIdResponse> => {
  return openApiFetch<personDeleteByIdResponse>(getPersonDeleteByIdUrl(params), {
    ...options,
    method: 'DELETE',
  });
};

export type newsDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type newsDeleteByIdResponseSuccess = newsDeleteByIdResponse200 & {
  headers: Headers;
};
export type newsDeleteByIdResponse = newsDeleteByIdResponseSuccess;

export const getNewsDeleteByIdUrl = (params: NewsDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/newsControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/newsControl/deleteById`;
};

export const newsDeleteById = async (
  params: NewsDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<newsDeleteByIdResponse> => {
  return openApiFetch<newsDeleteByIdResponse>(getNewsDeleteByIdUrl(params), {
    ...options,
    method: 'DELETE',
  });
};

export type mediaContentDeleteByIdResponse200 = {
  data: MediaContentDeleteResultDto;
  status: 200;
};

export type mediaContentDeleteByIdResponseSuccess = mediaContentDeleteByIdResponse200 & {
  headers: Headers;
};
export type mediaContentDeleteByIdResponse = mediaContentDeleteByIdResponseSuccess;

export const getMediaContentDeleteByIdUrl = (params: MediaContentDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/mediaContentControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/mediaContentControl/deleteById`;
};

export const mediaContentDeleteById = async (
  params: MediaContentDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<mediaContentDeleteByIdResponse> => {
  return openApiFetch<mediaContentDeleteByIdResponse>(getMediaContentDeleteByIdUrl(params), {
    ...options,
    method: 'DELETE',
  });
};

export type institutePredSuccDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type institutePredSuccDeleteByIdResponseSuccess = institutePredSuccDeleteByIdResponse200 & {
  headers: Headers;
};
export type institutePredSuccDeleteByIdResponse = institutePredSuccDeleteByIdResponseSuccess;

export const getInstitutePredSuccDeleteByIdUrl = (params: InstitutePredSuccDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/institutePredSuccControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/institutePredSuccControl/deleteById`;
};

export const institutePredSuccDeleteById = async (
  params: InstitutePredSuccDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<institutePredSuccDeleteByIdResponse> => {
  return openApiFetch<institutePredSuccDeleteByIdResponse>(
    getInstitutePredSuccDeleteByIdUrl(params),
    {
      ...options,
      method: 'DELETE',
    }
  );
};

export type culturalEntityRelationshipDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type culturalEntityRelationshipDeleteByIdResponseSuccess =
  culturalEntityRelationshipDeleteByIdResponse200 & {
    headers: Headers;
  };
export type culturalEntityRelationshipDeleteByIdResponse =
  culturalEntityRelationshipDeleteByIdResponseSuccess;

export const getCulturalEntityRelationshipDeleteByIdUrl = (
  params: CulturalEntityRelationshipDeleteByIdParams
) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityRelationshipControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityRelationshipControl/deleteById`;
};

export const culturalEntityRelationshipDeleteById = async (
  params: CulturalEntityRelationshipDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityRelationshipDeleteByIdResponse> => {
  return openApiFetch<culturalEntityRelationshipDeleteByIdResponse>(
    getCulturalEntityRelationshipDeleteByIdUrl(params),
    {
      ...options,
      method: 'DELETE',
    }
  );
};

export type culturalEntityDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type culturalEntityDeleteByIdResponseSuccess = culturalEntityDeleteByIdResponse200 & {
  headers: Headers;
};
export type culturalEntityDeleteByIdResponse = culturalEntityDeleteByIdResponseSuccess;

export const getCulturalEntityDeleteByIdUrl = (params: CulturalEntityDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/culturalEntityControl/deleteById`;
};

export const culturalEntityDeleteById = async (
  params: CulturalEntityDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<culturalEntityDeleteByIdResponse> => {
  return openApiFetch<culturalEntityDeleteByIdResponse>(getCulturalEntityDeleteByIdUrl(params), {
    ...options,
    method: 'DELETE',
  });
};

export type awardingPredSuccDeleteByIdResponse200 = {
  data: boolean;
  status: 200;
};

export type awardingPredSuccDeleteByIdResponseSuccess = awardingPredSuccDeleteByIdResponse200 & {
  headers: Headers;
};
export type awardingPredSuccDeleteByIdResponse = awardingPredSuccDeleteByIdResponseSuccess;

export const getAwardingPredSuccDeleteByIdUrl = (params: AwardingPredSuccDeleteByIdParams) => {
  const normalizedParams = new URLSearchParams();

  Object.entries(params || {}).forEach(([key, value]) => {
    if (value !== undefined) {
      normalizedParams.append(key, value === null ? 'null' : String(value));
    }
  });

  const stringifiedParams = normalizedParams.toString();

  return stringifiedParams.length > 0
    ? `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingPredSuccControl/deleteById?${stringifiedParams}`
    : `${process.env.NEXT_PUBLIC_NEW_API_URL}/api/auth/awardingPredSuccControl/deleteById`;
};

export const awardingPredSuccDeleteById = async (
  params: AwardingPredSuccDeleteByIdParams,
  options?: Parameters<typeof openApiFetch>[1]
): Promise<awardingPredSuccDeleteByIdResponse> => {
  return openApiFetch<awardingPredSuccDeleteByIdResponse>(
    getAwardingPredSuccDeleteByIdUrl(params),
    {
      ...options,
      method: 'DELETE',
    }
  );
};
