/**
 * Do not edit this file it is auto-generated by io-utils / gen-api-models.
 * See https://github.com/pagopa/io-utils
 */
/* tslint:disable */

import {
  RequestParams,
  TypeofApiCall,
  TypeofApiParams,
  createFetchRequestForApi,
  ReplaceRequestParams
} from "italia-ts-commons/lib/requests";
import { identity } from "fp-ts/lib/function";

import {
  GetServiceT,
  getServiceDefaultDecoder,
  UpdateServiceT,
  updateServiceDefaultDecoder,
  UploadServiceLogoT,
  uploadServiceLogoDefaultDecoder,
  GetServicesT,
  getServicesDefaultDecoder,
  CreateServiceT,
  createServiceDefaultDecoder,
  UploadOrganizationLogoT,
  uploadOrganizationLogoDefaultDecoder,
  CreateDevelopmentProfileT,
  createDevelopmentProfileDefaultDecoder,
  GetSubscriptionKeysT,
  getSubscriptionKeysDefaultDecoder,
  RegenerateSubscriptionKeysT,
  RegenerateSubscriptionKeysDefaultDecoder,
  GetUsersT,
  getUsersDefaultDecoder,
  CreateUserT,
  createUserDefaultDecoder,
  GetUserT,
  getUserDefaultDecoder,
  UpdateUserT,
  updateUserDefaultDecoder,
  UpdateGroupsT,
  updateGroupsDefaultDecoder,
  CreateSubscriptionT,
  createSubscriptionDefaultDecoder
} from "./requestTypes";

// This is a placeholder for undefined when dealing with object keys
// Typescript doesn't perform well when narrowing a union type which includes string and undefined
// (example: "foo" | "bar" | undefined)
// We use this as a placeholder for type parameters indicating "no key"
type __UNDEFINED_KEY = "_____";

export type ApiOperation = TypeofApiCall<GetServiceT> &
  TypeofApiCall<UpdateServiceT> &
  TypeofApiCall<UploadServiceLogoT> &
  TypeofApiCall<GetServicesT> &
  TypeofApiCall<CreateServiceT> &
  TypeofApiCall<UploadOrganizationLogoT> &
  TypeofApiCall<CreateDevelopmentProfileT> &
  TypeofApiCall<GetSubscriptionKeysT> &
  TypeofApiCall<RegenerateSubscriptionKeysT> &
  TypeofApiCall<GetUsersT> &
  TypeofApiCall<CreateUserT> &
  TypeofApiCall<GetUserT> &
  TypeofApiCall<UpdateUserT> &
  TypeofApiCall<UpdateGroupsT> &
  TypeofApiCall<CreateSubscriptionT>;

export type ParamKeys = keyof (TypeofApiParams<GetServiceT> &
  TypeofApiParams<UpdateServiceT> &
  TypeofApiParams<UploadServiceLogoT> &
  TypeofApiParams<GetServicesT> &
  TypeofApiParams<CreateServiceT> &
  TypeofApiParams<UploadOrganizationLogoT> &
  TypeofApiParams<CreateDevelopmentProfileT> &
  TypeofApiParams<GetSubscriptionKeysT> &
  TypeofApiParams<RegenerateSubscriptionKeysT> &
  TypeofApiParams<GetUsersT> &
  TypeofApiParams<CreateUserT> &
  TypeofApiParams<GetUserT> &
  TypeofApiParams<UpdateUserT> &
  TypeofApiParams<UpdateGroupsT> &
  TypeofApiParams<CreateSubscriptionT>);

/**
 * Defines an adapter for TypeofApiCall which omit one or more parameters in the signature
 * @param ApiT the type which defines the operation to expose
 * @param K the parameter to omit. undefined means no parameters will be omitted
 */
export type OmitApiCallParams<
  ApiT,
  K extends ParamKeys | __UNDEFINED_KEY = __UNDEFINED_KEY
> = (
  op: TypeofApiCall<ApiT>
) => K extends __UNDEFINED_KEY
  ? TypeofApiCall<ApiT>
  : TypeofApiCall<ReplaceRequestParams<ApiT, Omit<RequestParams<ApiT>, K>>>;

/**
 * Defines an adapter for TypeofApiCall which omit one or more parameters in the signature
 * @param ApiT the type which defines the operation to expose
 * @param K the parameter to omit. undefined means no parameters will be omitted
 */
export type WithDefaultsT<
  K extends ParamKeys | __UNDEFINED_KEY = __UNDEFINED_KEY
> = OmitApiCallParams<
  | GetServiceT
  | UpdateServiceT
  | UploadServiceLogoT
  | GetServicesT
  | CreateServiceT
  | UploadOrganizationLogoT
  | CreateDevelopmentProfileT
  | GetSubscriptionKeysT
  | RegenerateSubscriptionKeysT
  | GetUsersT
  | CreateUserT
  | GetUserT
  | UpdateUserT
  | UpdateGroupsT
  | CreateSubscriptionT,
  K
>;

/**
 * Defines a collection of api operations
 * @param K name of the parameters that the Clients masks from the operations
 */
export type Client<
  K extends ParamKeys | __UNDEFINED_KEY = __UNDEFINED_KEY
> = K extends __UNDEFINED_KEY
  ? {
      readonly getService: TypeofApiCall<GetServiceT>;

      readonly updateService: TypeofApiCall<UpdateServiceT>;

      readonly uploadServiceLogo: TypeofApiCall<UploadServiceLogoT>;

      readonly getServices: TypeofApiCall<GetServicesT>;

      readonly createService: TypeofApiCall<CreateServiceT>;

      readonly uploadOrganizationLogo: TypeofApiCall<UploadOrganizationLogoT>;

      readonly createDevelopmentProfile: TypeofApiCall<
        CreateDevelopmentProfileT
      >;

      readonly getSubscriptionKeys: TypeofApiCall<GetSubscriptionKeysT>;

      readonly RegenerateSubscriptionKeys: TypeofApiCall<
        RegenerateSubscriptionKeysT
      >;

      readonly getUsers: TypeofApiCall<GetUsersT>;

      readonly createUser: TypeofApiCall<CreateUserT>;

      readonly getUser: TypeofApiCall<GetUserT>;

      readonly updateUser: TypeofApiCall<UpdateUserT>;

      readonly updateGroups: TypeofApiCall<UpdateGroupsT>;

      readonly createSubscription: TypeofApiCall<CreateSubscriptionT>;
    }
  : {
      readonly getService: TypeofApiCall<
        ReplaceRequestParams<GetServiceT, Omit<RequestParams<GetServiceT>, K>>
      >;

      readonly updateService: TypeofApiCall<
        ReplaceRequestParams<
          UpdateServiceT,
          Omit<RequestParams<UpdateServiceT>, K>
        >
      >;

      readonly uploadServiceLogo: TypeofApiCall<
        ReplaceRequestParams<
          UploadServiceLogoT,
          Omit<RequestParams<UploadServiceLogoT>, K>
        >
      >;

      readonly getServices: TypeofApiCall<
        ReplaceRequestParams<GetServicesT, Omit<RequestParams<GetServicesT>, K>>
      >;

      readonly createService: TypeofApiCall<
        ReplaceRequestParams<
          CreateServiceT,
          Omit<RequestParams<CreateServiceT>, K>
        >
      >;

      readonly uploadOrganizationLogo: TypeofApiCall<
        ReplaceRequestParams<
          UploadOrganizationLogoT,
          Omit<RequestParams<UploadOrganizationLogoT>, K>
        >
      >;

      readonly createDevelopmentProfile: TypeofApiCall<
        ReplaceRequestParams<
          CreateDevelopmentProfileT,
          Omit<RequestParams<CreateDevelopmentProfileT>, K>
        >
      >;

      readonly getSubscriptionKeys: TypeofApiCall<
        ReplaceRequestParams<
          GetSubscriptionKeysT,
          Omit<RequestParams<GetSubscriptionKeysT>, K>
        >
      >;

      readonly RegenerateSubscriptionKeys: TypeofApiCall<
        ReplaceRequestParams<
          RegenerateSubscriptionKeysT,
          Omit<RequestParams<RegenerateSubscriptionKeysT>, K>
        >
      >;

      readonly getUsers: TypeofApiCall<
        ReplaceRequestParams<GetUsersT, Omit<RequestParams<GetUsersT>, K>>
      >;

      readonly createUser: TypeofApiCall<
        ReplaceRequestParams<CreateUserT, Omit<RequestParams<CreateUserT>, K>>
      >;

      readonly getUser: TypeofApiCall<
        ReplaceRequestParams<GetUserT, Omit<RequestParams<GetUserT>, K>>
      >;

      readonly updateUser: TypeofApiCall<
        ReplaceRequestParams<UpdateUserT, Omit<RequestParams<UpdateUserT>, K>>
      >;

      readonly updateGroups: TypeofApiCall<
        ReplaceRequestParams<
          UpdateGroupsT,
          Omit<RequestParams<UpdateGroupsT>, K>
        >
      >;

      readonly createSubscription: TypeofApiCall<
        ReplaceRequestParams<
          CreateSubscriptionT,
          Omit<RequestParams<CreateSubscriptionT>, K>
        >
      >;
    };

/**
 * Create an instance of a client
 * @param params hash map of parameters thata define the client:
 *  - baseUrl: the base url for every api call (required)
 *  - fetchApi: an implementation of the fetch() web API, depending on the platform (required)
 *  - basePath: optional path to be appended to the baseUrl
 *  - withDefaults: optional adapter to be applied to every operation, to omit some paramenters
 * @returns a collection of api operations
 */
export function createClient<K extends ParamKeys>(params: {
  baseUrl: string;
  // tslint:disable-next-line:no-any
  fetchApi: typeof fetch;
  withDefaults: WithDefaultsT<K>;
  basePath?: string;
}): Client<K>;
export function createClient(params: {
  baseUrl: string;
  // tslint:disable-next-line:no-any
  fetchApi: typeof fetch;
  withDefaults?: undefined;
  basePath?: string;
}): Client;
export function createClient<K extends ParamKeys>({
  baseUrl,
  // tslint:disable-next-line:no-any
  fetchApi,
  withDefaults,
  basePath = "/adm"
}: {
  baseUrl: string;
  // tslint:disable-next-line:no-any
  fetchApi: typeof fetch;
  withDefaults?: WithDefaultsT<K>;
  basePath?: string;
}) {
  const options = {
    baseUrl,
    fetchApi
  };

  const getServiceT: ReplaceRequestParams<
    GetServiceT,
    RequestParams<GetServiceT>
  > = {
    method: "get",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey
    }),
    response_decoder: getServiceDefaultDecoder(),
    url: ({ ["service_id"]: serviceId }) => `${basePath}/services/${serviceId}`,

    query: () => ({})
  };
  const getService: TypeofApiCall<GetServiceT> = createFetchRequestForApi(
    getServiceT,
    options
  );

  const updateServiceT: ReplaceRequestParams<
    UpdateServiceT,
    RequestParams<UpdateServiceT>
  > = {
    method: "put",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey,

      "Content-Type": "application/json"
    }),
    response_decoder: updateServiceDefaultDecoder(),
    url: ({ ["service_id"]: serviceId }) => `${basePath}/services/${serviceId}`,

    body: ({ ["body"]: body }) => JSON.stringify(body),

    query: () => ({})
  };
  const updateService: TypeofApiCall<UpdateServiceT> = createFetchRequestForApi(
    updateServiceT,
    options
  );

  const uploadServiceLogoT: ReplaceRequestParams<
    UploadServiceLogoT,
    RequestParams<UploadServiceLogoT>
  > = {
    method: "put",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey,

      "Content-Type": "application/json"
    }),
    response_decoder: uploadServiceLogoDefaultDecoder(),
    url: ({ ["service_id"]: serviceId }) =>
      `${basePath}/services/${serviceId}/logo`,

    body: ({ ["body"]: body }) => JSON.stringify(body),

    query: () => ({})
  };
  const uploadServiceLogo: TypeofApiCall<UploadServiceLogoT> = createFetchRequestForApi(
    uploadServiceLogoT,
    options
  );

  const getServicesT: ReplaceRequestParams<
    GetServicesT,
    RequestParams<GetServicesT>
  > = {
    method: "get",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey
    }),
    response_decoder: getServicesDefaultDecoder(),
    url: ({}) => `${basePath}/services`,

    query: () => ({})
  };
  const getServices: TypeofApiCall<GetServicesT> = createFetchRequestForApi(
    getServicesT,
    options
  );

  const createServiceT: ReplaceRequestParams<
    CreateServiceT,
    RequestParams<CreateServiceT>
  > = {
    method: "post",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey,

      "Content-Type": "application/json"
    }),
    response_decoder: createServiceDefaultDecoder(),
    url: ({}) => `${basePath}/services`,

    body: ({ ["body"]: body }) => JSON.stringify(body),

    query: () => ({})
  };
  const createService: TypeofApiCall<CreateServiceT> = createFetchRequestForApi(
    createServiceT,
    options
  );

  const uploadOrganizationLogoT: ReplaceRequestParams<
    UploadOrganizationLogoT,
    RequestParams<UploadOrganizationLogoT>
  > = {
    method: "put",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey,

      "Content-Type": "application/json"
    }),
    response_decoder: uploadOrganizationLogoDefaultDecoder(),
    url: ({ ["organization_fiscal_code"]: organizationFiscalCode }) =>
      `${basePath}/organizations/${organizationFiscalCode}/logo`,

    body: ({ ["body"]: body }) => JSON.stringify(body),

    query: () => ({})
  };
  const uploadOrganizationLogo: TypeofApiCall<UploadOrganizationLogoT> = createFetchRequestForApi(
    uploadOrganizationLogoT,
    options
  );

  const createDevelopmentProfileT: ReplaceRequestParams<
    CreateDevelopmentProfileT,
    RequestParams<CreateDevelopmentProfileT>
  > = {
    method: "post",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey,

      "Content-Type": "application/json"
    }),
    response_decoder: createDevelopmentProfileDefaultDecoder(),
    url: ({ ["fiscal_code"]: fiscalCode }) =>
      `${basePath}/development-profiles/${fiscalCode}`,

    body: ({ ["body"]: body }) => JSON.stringify(body),

    query: () => ({})
  };
  const createDevelopmentProfile: TypeofApiCall<CreateDevelopmentProfileT> = createFetchRequestForApi(
    createDevelopmentProfileT,
    options
  );

  const getSubscriptionKeysT: ReplaceRequestParams<
    GetSubscriptionKeysT,
    RequestParams<GetSubscriptionKeysT>
  > = {
    method: "get",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey
    }),
    response_decoder: getSubscriptionKeysDefaultDecoder(),
    url: ({ ["service_id"]: serviceId }) =>
      `${basePath}/services/${serviceId}/keys`,

    query: () => ({})
  };
  const getSubscriptionKeys: TypeofApiCall<GetSubscriptionKeysT> = createFetchRequestForApi(
    getSubscriptionKeysT,
    options
  );

  const RegenerateSubscriptionKeysT: ReplaceRequestParams<
    RegenerateSubscriptionKeysT,
    RequestParams<RegenerateSubscriptionKeysT>
  > = {
    method: "put",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey,

      "Content-Type": "application/json"
    }),
    response_decoder: RegenerateSubscriptionKeysDefaultDecoder(),
    url: ({ ["service_id"]: serviceId }) =>
      `${basePath}/services/${serviceId}/keys`,

    body: ({ ["body"]: body }) => JSON.stringify(body),

    query: () => ({})
  };
  const RegenerateSubscriptionKeys: TypeofApiCall<RegenerateSubscriptionKeysT> = createFetchRequestForApi(
    RegenerateSubscriptionKeysT,
    options
  );

  const getUsersT: ReplaceRequestParams<GetUsersT, RequestParams<GetUsersT>> = {
    method: "get",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey
    }),
    response_decoder: getUsersDefaultDecoder(),
    url: ({}) => `${basePath}/users`,

    query: ({ ["cursor"]: cursor }) => ({ cursor })
  };
  const getUsers: TypeofApiCall<GetUsersT> = createFetchRequestForApi(
    getUsersT,
    options
  );

  const createUserT: ReplaceRequestParams<
    CreateUserT,
    RequestParams<CreateUserT>
  > = {
    method: "post",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey,

      "Content-Type": "application/json"
    }),
    response_decoder: createUserDefaultDecoder(),
    url: ({}) => `${basePath}/users`,

    body: ({ ["body"]: body }) => JSON.stringify(body),

    query: () => ({})
  };
  const createUser: TypeofApiCall<CreateUserT> = createFetchRequestForApi(
    createUserT,
    options
  );

  const getUserT: ReplaceRequestParams<GetUserT, RequestParams<GetUserT>> = {
    method: "get",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey
    }),
    response_decoder: getUserDefaultDecoder(),
    url: ({ ["email"]: email }) => `${basePath}/users/${email}`,

    query: () => ({})
  };
  const getUser: TypeofApiCall<GetUserT> = createFetchRequestForApi(
    getUserT,
    options
  );

  const updateUserT: ReplaceRequestParams<
    UpdateUserT,
    RequestParams<UpdateUserT>
  > = {
    method: "put",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey,

      "Content-Type": "application/json"
    }),
    response_decoder: updateUserDefaultDecoder(),
    url: ({ ["email"]: email }) => `${basePath}/users/${email}`,

    body: ({ ["body"]: body }) => JSON.stringify(body),

    query: () => ({})
  };
  const updateUser: TypeofApiCall<UpdateUserT> = createFetchRequestForApi(
    updateUserT,
    options
  );

  const updateGroupsT: ReplaceRequestParams<
    UpdateGroupsT,
    RequestParams<UpdateGroupsT>
  > = {
    method: "put",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey,

      "Content-Type": "application/json"
    }),
    response_decoder: updateGroupsDefaultDecoder(),
    url: ({ ["email"]: email }) => `${basePath}/users/${email}/groups`,

    body: ({ ["body"]: body }) => JSON.stringify(body),

    query: () => ({})
  };
  const updateGroups: TypeofApiCall<UpdateGroupsT> = createFetchRequestForApi(
    updateGroupsT,
    options
  );

  const createSubscriptionT: ReplaceRequestParams<
    CreateSubscriptionT,
    RequestParams<CreateSubscriptionT>
  > = {
    method: "put",

    headers: ({
      ["SubscriptionKey"]: SubscriptionKey
    }: {
      SubscriptionKey: string;
    }) => ({
      "Ocp-Apim-Subscription-Key": SubscriptionKey,

      "Content-Type": "application/json"
    }),
    response_decoder: createSubscriptionDefaultDecoder(),
    url: ({ ["email"]: email, ["subscription_id"]: subscriptionId }) =>
      `${basePath}/users/${email}/subscriptions/${subscriptionId}`,

    body: ({ ["body"]: body }) => JSON.stringify(body),

    query: () => ({})
  };
  const createSubscription: TypeofApiCall<CreateSubscriptionT> = createFetchRequestForApi(
    createSubscriptionT,
    options
  );

  return {
    getService: (withDefaults || identity)(getService),
    updateService: (withDefaults || identity)(updateService),
    uploadServiceLogo: (withDefaults || identity)(uploadServiceLogo),
    getServices: (withDefaults || identity)(getServices),
    createService: (withDefaults || identity)(createService),
    uploadOrganizationLogo: (withDefaults || identity)(uploadOrganizationLogo),
    createDevelopmentProfile: (withDefaults || identity)(
      createDevelopmentProfile
    ),
    getSubscriptionKeys: (withDefaults || identity)(getSubscriptionKeys),
    RegenerateSubscriptionKeys: (withDefaults || identity)(
      RegenerateSubscriptionKeys
    ),
    getUsers: (withDefaults || identity)(getUsers),
    createUser: (withDefaults || identity)(createUser),
    getUser: (withDefaults || identity)(getUser),
    updateUser: (withDefaults || identity)(updateUser),
    updateGroups: (withDefaults || identity)(updateGroups),
    createSubscription: (withDefaults || identity)(createSubscription)
  };
}