@jwork-space/strapi-sdk 1.0.1

package/dist/index.d.mts

@@ -0,0 +1,539 @@
+import { UploadFile, FormInstance } from 'antd';
+import { ColumnType } from 'antd/es/table';
+import axios, { AxiosRequestHeaders } from 'axios';
+import { ReactNode } from 'react';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { Rule } from 'antd/es/form';
+import { SorterResult } from 'antd/es/table/interface';
+
+declare class LocalStoreManager {
+    protected tokenKey: string;
+    constructor(tokenKey?: string);
+    getLocalStorageKey(key: string): string | null;
+    removeStorageKey(key: string): void;
+    setLocalStorage(key: string, value: string): void;
+    getToken(): string | null;
+    setToken(token: string): void;
+    removeToken(): void;
+}
+type BuilderHeaders = () => AxiosRequestHeaders;
+declare class HttpLayer {
+    protected tokenManager: LocalStoreManager;
+    constructor(tokenKey?: string);
+    private mergeHeaders;
+    protected getHeaders({ auth, headers }: RequestData, uri: string): axios.AxiosRequestHeaders;
+    makeRequest<U>(uri: string, method: 'get' | 'put' | 'post' | 'delete', opt?: RequestData): Promise<U>;
+    executeRequest<U>(uri: string, method: 'get' | 'put' | 'post' | 'delete' | 'patch', opt?: RequestData): Promise<axios.AxiosResponse<U, any, {}>>;
+    makeRequestV2<U>(uri: string, method: 'get' | 'put' | 'post' | 'delete', opt?: RequestData): Promise<axios.AxiosResponse<U, any, {}>>;
+    getFileName(contentDisposition: string): string;
+    getFileFromAPI({ uri, method, opt, fileName, }: {
+        fileName?: string;
+        uri: string;
+        method: 'get' | 'put' | 'post' | 'delete';
+        opt: RequestData;
+    }): Promise<void>;
+    getCall<U>(uri: string, opt?: RequestData): Promise<U>;
+    postCall<U>(uri: string, opt?: RequestData): Promise<U>;
+    putCall<U>(uri: string, opt?: RequestData): Promise<U>;
+    deleteCall<U>(uri: string, opt?: RequestData): Promise<U>;
+}
+
+declare const buildPath: (...segments: (string | undefined | null)[]) => string;
+declare abstract class BaseAPI<T> extends HttpLayer {
+    protected resource?: string | undefined;
+    protected prefix?: string | undefined;
+    protected tokenKey?: string | undefined;
+    protected baseURL?: string | undefined;
+    protected endpoint: string;
+    constructor(resource?: string | undefined, prefix?: string | undefined, tokenKey?: string | undefined, baseURL?: string | undefined);
+    buildPath: (...segments: (string | undefined | null)[]) => string;
+    normalizePath: (value: string) => string;
+    abstract listAll(requestOptions?: RequestOptions<T>): Promise<PaginationResponse<T>>;
+    abstract show(id: ModelID, requestOptions?: RequestOptions<T>): Promise<T>;
+    abstract save(model: T, requestOptions?: RequestOptions<T>, serializeOptions?: SerializeOptions, relationApi?: RelationCreate<T>[]): Promise<T>;
+    abstract update(id: ModelID, model: T, requestOptions?: RequestOptions<T>, serializeOptions?: SerializeOptions): Promise<T>;
+    abstract destroy(id: ModelID, requestOptions?: RequestOptions<T>): Promise<boolean>;
+    abstract exist(requestOptions?: RequestOptions<T>): Promise<boolean>;
+}
+
+type InvalidateKeysMap = {
+    save?: (string | unknown[])[];
+    update?: (string | unknown[])[];
+    destroy?: (string | unknown[])[];
+};
+interface StrapiConfig {
+    wrapBodyInData?: boolean;
+    transformResponse?: boolean;
+    pageSize?: number;
+    prefix?: string;
+    tokenKey?: string;
+    onCreate?: {
+        generateUID?: boolean;
+        keyUID?: string;
+    };
+    defaultQueriesInvalidations?: InvalidateKeysMap;
+    baseURL?: string;
+}
+interface MetaResponse {
+    pagination: Omit<Pagination, "currentTotal">;
+}
+interface RawResponse<T> {
+    data: T;
+    meta: MetaResponse;
+}
+type BaseModel = AnyObject & {
+    id?: ModelID;
+};
+type InvalidateOpt = {
+    invalidateKeys?: (string | unknown[])[];
+    onSuccess?: (data?: any) => void;
+    onError?: (error: unknown) => void;
+};
+interface PayloadRequest<T> {
+    data: T;
+    requestOptions?: RequestOptions<T>;
+    serializeOptions?: SerializeOptions;
+}
+interface PayloadRequestUpdate<T> {
+    data: T;
+    id: ModelID;
+    requestOptions?: RequestOptions<T>;
+    serializeOptions?: SerializeOptions;
+}
+interface PayloadRequestUpsert<T> {
+    data: T;
+    id: ModelID;
+    requestOptions?: RequestOptions<T>;
+    serializeOptions?: SerializeOptions;
+}
+interface PayloadRequestUpload {
+    fileList: UploadFile[];
+    oldImages?: StrapiImage[];
+}
+declare class StrapiSDK<T extends BaseModel> extends BaseAPI<T> {
+    private defaultInvalidateKeys?;
+    private config;
+    constructor(resource: string, config?: StrapiConfig);
+    exist: (opt: RequestOptions<T>) => Promise<boolean>;
+    protected getQueryParams(opt?: RequestOptions<T>): AnyObject & {
+        filters?: AnyObject;
+    };
+    protected normalizeBody(model: T, action: "save" | "update", { multipart, transformModel }: RequestOptions<T>, serializeOptions?: SerializeOptions): AnyObject | FormData;
+    protected getRequestParams(opt?: RequestOptions<T>): RequestData;
+    requestExecutor({ uri, data }: {
+        uri: string;
+        data: RequestData;
+    }): Promise<any>;
+    listAll: (opt?: RequestOptions<T>) => Promise<PaginationResponse<T>>;
+    getAllData: (options?: RequestOptions<T>) => Promise<{
+        data: T[];
+        opt: {
+            auth?: boolean;
+            delay?: number;
+            url?: string;
+            method?: "get" | "post" | "put" | "delete";
+            sort: string | string[];
+            excludeFilterEnterprise?: boolean;
+            filters?: FilterParametersCustom<T> | undefined;
+            populate?: PopulateParams<T> | undefined;
+            fields?: string[];
+            permissions?: string[];
+            pagination: PaginationRequest;
+            extraQuery?: AnyObject;
+            forceUpdateStrapiUID?: boolean;
+            multipart?: ((model: T, action: "save" | "update") => FormData) | undefined;
+            transformModel?: ((model: T, action: "save" | "update") => T) | undefined;
+        };
+        paging: {
+            pageCount: number;
+        };
+        pagination: PaginationRequest;
+    }>;
+    show: (id: ModelID, opt?: RequestOptions<T>) => Promise<T>;
+    patchRequest: (options: SerializeOptions, id?: ModelID, opt?: RequestOptions<T>) => {
+        uri: string;
+        options?: undefined;
+    } | {
+        uri: string;
+        options: string[];
+    };
+    private buildPayloadToStore;
+    store: (model: T, id?: ModelID, opt?: RequestOptions<T>, serializeOptions?: SerializeOptions) => Promise<T>;
+    save: (model: T, opt?: RequestOptions<T>, serializeOptions?: SerializeOptions) => Promise<T>;
+    update: (id: ModelID, model: T, opt?: RequestOptions<T>, serializeOptions?: SerializeOptions) => Promise<T>;
+    updateOne: (model: T, opt: RequestOptions<T>, serializeOptions?: SerializeOptions, _createRelations?: RelationCreate<T>[]) => Promise<RawResponse<T>>;
+    destroy: (id: ModelID, opt?: RequestOptions<T>) => Promise<boolean>;
+    findOne: (opt?: RequestOptions<T>) => Promise<T | null>;
+    findById: (id: number, opt?: RequestOptions<T>) => Promise<T>;
+    serialize(model: T | AnyObject, options?: SerializeOptions): AnyObject;
+    private shouldSkipKey;
+    private transformValue;
+    private buildOptions;
+    private serializeArray;
+    useListAll: (opt?: RequestOptions<T>) => _tanstack_react_query.UseQueryResult<PaginationResponse<T>, Error>;
+    useListAllCustom: (opt?: RequestOptions<T>, enabled?: boolean) => _tanstack_react_query.UseQueryResult<PaginationResponse<T>, Error>;
+    useGetAllData: (opt?: RequestOptions<T>) => _tanstack_react_query.UseQueryResult<{
+        data: T[];
+        opt: {
+            auth?: boolean;
+            delay?: number;
+            url?: string;
+            method?: "get" | "post" | "put" | "delete";
+            sort: string | string[];
+            excludeFilterEnterprise?: boolean;
+            filters?: FilterParametersCustom<T> | undefined;
+            populate?: PopulateParams<T> | undefined;
+            fields?: string[];
+            permissions?: string[];
+            pagination: PaginationRequest;
+            extraQuery?: AnyObject;
+            forceUpdateStrapiUID?: boolean;
+            multipart?: ((model: T, action: "save" | "update") => FormData) | undefined;
+            transformModel?: ((model: T, action: "save" | "update") => T) | undefined;
+        };
+        paging: {
+            pageCount: number;
+        };
+        pagination: PaginationRequest;
+    }, Error>;
+    useGetAllDataCustom: (opt?: RequestOptions<T>, enabled?: boolean) => _tanstack_react_query.UseQueryResult<T[], Error>;
+    useExistEntity: (opt: RequestOptions<T>) => _tanstack_react_query.UseQueryResult<boolean, Error>;
+    useShow: (id: ModelID, opt?: RequestOptions<T>) => _tanstack_react_query.UseQueryResult<_tanstack_react_query.NoInfer<T>, Error>;
+    useFindOneAsync: (opt?: RequestOptions<T>, enabled?: boolean) => _tanstack_react_query.UseQueryResult<_tanstack_react_query.NoInfer<T | null>, Error>;
+    useFindOne: (opt?: RequestOptions<T>) => _tanstack_react_query.UseQueryResult<_tanstack_react_query.NoInfer<T | null>, Error>;
+    useFindById: (id: number, opt?: RequestOptions<T>) => _tanstack_react_query.UseQueryResult<_tanstack_react_query.NoInfer<T>, Error>;
+    private getInvalidateKeys;
+    useStore: (opt?: InvalidateOpt) => _tanstack_react_query.UseMutationResult<T, Error, PayloadRequestUpdate<T>, unknown>;
+    useSave: (opt?: InvalidateOpt) => _tanstack_react_query.UseMutationResult<T, Error, PayloadRequest<T>, unknown>;
+    useUpdate: (opt?: InvalidateOpt) => _tanstack_react_query.UseMutationResult<T, Error, PayloadRequestUpdate<T>, unknown>;
+    useUpsert: (opt?: InvalidateOpt) => _tanstack_react_query.UseMutationResult<T, Error, PayloadRequestUpsert<T>, unknown>;
+    useDestroy: (opt?: InvalidateOpt) => _tanstack_react_query.UseMutationResult<boolean, Error, ModelID, unknown>;
+    findOrCreate(data: T, optFind: RequestOptions<T>, optPayload?: RequestOptions<T>, serializeOptionsPayload?: SerializeOptions): Promise<T>;
+    findAndUpdate(data: T, optFilter: RequestOptions<T>, optPayload?: RequestOptions<T>, serializeOptionsPayload?: SerializeOptions): Promise<T | undefined>;
+    finOneEntity: (opt?: RequestOptions<T>) => Promise<T | null>;
+    upsert(data: T, opt?: RequestOptions<T>, serializeOptions?: SerializeOptions): Promise<T>;
+}
+
+type AnyObject = Record<string, any>;
+type AnyValue = any;
+interface Pagination {
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    total: number;
+    currentTotal: number;
+    withCount?: boolean;
+}
+interface PaginationRequest {
+    page: number;
+    pageSize: number;
+}
+type ModelID = string | number | undefined;
+type ConstructorWithParams<T> = {
+    new (...arguments_: AnyValue[]): T;
+};
+interface RelationCreate<T> {
+    propModel: keyof T;
+    api: BaseAPI<T>;
+}
+interface PaginationResponse<T> {
+    data: T[];
+    pagination: Pagination;
+}
+interface SerializeOptions {
+    exclude?: string[];
+    onlyIdForRelations?: boolean;
+    preserveBlank?: boolean;
+    preserveRelations?: string[];
+    removeEmptyArrays?: boolean;
+    removeEmptyObjects?: boolean;
+}
+interface FilterTypesCustom {
+    $in?: string[] | number[];
+    $contains?: string;
+    $containsi?: string;
+    $notContainsi?: string;
+    $null?: boolean;
+    $between?: AnyObject[];
+    $lte?: number | string;
+    $lt?: number | string;
+    $gte?: number | string;
+    $gt?: number | string;
+    $eq?: string | number | boolean;
+    $ne?: string | number;
+}
+type OperatorsCustom<T> = T extends object ? {
+    $and?: Array<FilterParametersCustom<T> | Partial<T>>;
+    $or?: Array<FilterParametersCustom<T> | Partial<T>>;
+    $between?: AnyValue[];
+    $in?: string[] | number[];
+} : {};
+type FilterParametersCustom<T> = {
+    [K in keyof T as T[K] extends (...arguments_: AnyValue[]) => AnyValue ? never : K]?: T[K] extends number | string | boolean | undefined ? FilterTypesCustom | T[K] : T[K] extends (infer U)[] ? FilterParametersCustom<U> | U | number : T[K] extends object ? FilterParametersCustom<T[K]> | number : FilterParametersCustom<T[K]>;
+} & OperatorsCustom<T>;
+interface RequestData {
+    query?: AnyObject & {
+        extraQuery?: AnyObject;
+    };
+    auth?: boolean;
+    headers?: AxiosRequestHeaders;
+    body?: AnyObject | AnyObject[] | FormData;
+    responseType?: "blob" | "json";
+}
+type FieldFilter<T> = T | {
+    $eq?: T;
+    $ne?: T;
+    $in?: T[];
+    $nin?: T[];
+    $gt?: T;
+    $lt?: T;
+    $gte?: T;
+    $lte?: T;
+    $contains?: string;
+    $containsi?: string;
+    $startsWith?: string;
+    $endsWith?: string;
+};
+type RawFilter<T> = {
+    [K in keyof T]?: NonNullable<T[K]> extends (infer U)[] ? U extends object ? RawFilter<U>[] : FieldFilter<U>[] : NonNullable<T[K]> extends object ? RawFilter<NonNullable<T[K]>> : FieldFilter<NonNullable<T[K]>>;
+} & {
+    $and?: RawFilter<T>[];
+    $or?: RawFilter<T>[];
+};
+interface PagingPopulate {
+    page?: number;
+    pageSize?: number;
+    withCount?: boolean;
+    limit?: number;
+}
+type ElementOf<T> = T extends ReadonlyArray<infer U> ? U : T extends Array<infer U> ? U : never;
+type PopulateParams<T> = {
+    pagination?: PagingPopulate;
+    sort?: string;
+    fields?: "*" | string[];
+    filters?: FilterParametersCustom<T>;
+    populate?: {
+        [K in keyof T]?: NonNullable<T[K]> extends infer Property ? Property extends Array<AnyValue> | ReadonlyArray<AnyValue> ? boolean | PopulateParams<ElementOf<Property>> : Property extends object ? boolean | PopulateParams<Property> : boolean : never;
+    };
+} & {
+    [K in keyof T]?: NonNullable<T[K]> extends infer Property ? Property extends Array<AnyValue> | ReadonlyArray<AnyValue> ? boolean | PopulateParams<ElementOf<Property>> : Property extends object ? boolean | PopulateParams<Property> : boolean : never;
+};
+interface RequestOptions<T> {
+    auth?: boolean;
+    delay?: number;
+    url?: string;
+    method?: "get" | "post" | "put" | "delete";
+    sort?: string | string[];
+    excludeFilterEnterprise?: boolean;
+    filters?: FilterParametersCustom<T>;
+    populate?: PopulateParams<T>;
+    fields?: string[];
+    permissions?: string[];
+    pagination?: PaginationRequest;
+    extraQuery?: AnyObject;
+    forceUpdateStrapiUID?: boolean;
+    multipart?: (model: T, action: "save" | "update") => FormData;
+    transformModel?: (model: T, action: "save" | "update") => T;
+}
+declare const publicRoutes: string[];
+declare function isObject(value: unknown): value is Record<string, unknown>;
+declare function isDefined<T>(value: T): value is T;
+declare function getKeyByValue<T, K extends keyof T>(object: T, value: T[K]): K | undefined;
+declare function isEmptyObject<T>(object: T): boolean;
+declare function isPlainObject(value: AnyValue): value is Record<string, any>;
+interface Credentials {
+    identifier: string;
+    password: string;
+}
+interface StrapiBaseInterface {
+    id: number;
+    strapiUID?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+interface StrapiRole extends StrapiBaseInterface {
+    name: string;
+    description: string;
+    type: string;
+}
+interface UserStrapiModel extends StrapiBaseInterface {
+    username?: string;
+    email?: string;
+    provider?: string;
+    password: string;
+    resetPasswordToken?: string;
+    confirmationToken?: string;
+    confirmed?: boolean;
+    blocked?: boolean;
+    role?: StrapiRole | number;
+    type?: string;
+    firstName?: string;
+    lastName?: string;
+    approved?: boolean;
+    setup_secret?: string;
+    expoPushToken?: string;
+}
+interface AuthResponse {
+    jwt: string;
+    user: UserStrapiModel;
+}
+interface StrapiAuthResponse {
+    data: AuthResponse;
+}
+interface ImageFormat {
+    url: string;
+    width: number;
+    height: number;
+}
+interface StrapiImageFormat {
+    thumbnail?: ImageFormat;
+    small?: ImageFormat;
+    medium?: ImageFormat;
+    large?: ImageFormat;
+}
+interface StrapiImage {
+    id: number;
+    name: string;
+    alternativeText: string;
+    caption: string;
+    width: number;
+    height: number;
+    formats: StrapiImageFormat;
+    hash: string;
+    ext: string;
+    mime: string;
+    size: number;
+    url: string;
+    previewUrl: string;
+    provider: string;
+    provider_metadata: string;
+    createdAt: string;
+    updatedAt: string;
+    isUrlSigned: boolean;
+    documentId?: number;
+    _id?: string;
+}
+type FieldType = "text" | "number" | "date" | "checkbox" | "radio" | "textarea" | "email" | "password" | "url";
+type FieldTag = "text" | "select" | "currency" | "checkbox" | "radio" | "number" | "textarea" | "email" | "password" | "url" | "table" | "hidden" | "submit" | "reset" | "button" | "image" | "file" | "color" | "date" | "dateRange" | "monthRange" | "time" | "week" | "year" | "selectMultiple" | "switch" | "slider" | "rate" | "search" | "treeSelect" | "upload" | "frame" | "radioGroup" | "inputSearch";
+interface FieldConfig<T extends BaseModel = BaseModel> extends ColumnType<T> {
+    name?: string;
+    customFilters?: RawFilter<T> | ((value: unknown) => AnyObject);
+    titleOnFilter?: string;
+    dataIndex: string;
+    title: string | ReactNode;
+    type?: FieldType;
+    tag?: FieldTag;
+    hiddenInTable?: boolean;
+    aliasToExport?: string;
+    excludeOnExport?: boolean;
+    formatter?: (value: T) => unknown;
+    hiddenOnTable?: boolean;
+    hiddenInForm?: boolean;
+    visible?: boolean;
+    placeholder?: string;
+    option?: {
+        options?: AnyValue[];
+        api: APIType<T>;
+        selectFirstOption: boolean;
+        currentModel: BaseModel;
+        required?: boolean;
+        itemKey?: string;
+        itemShow?: string | string[];
+        filterBy?: string | string[];
+        format: (options: AnyValue[]) => AnyValue[];
+        filters: FilterParametersCustom<T>;
+        populate: PopulateParams<T>;
+    };
+    sort?: {
+        active?: boolean;
+        default?: string;
+    };
+    height?: string;
+    heightImg?: number;
+    classes?: {
+        element?: string;
+        label?: string;
+        input?: string;
+    };
+    required?: boolean;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    rules?: Rule[];
+    maxLength?: number;
+    onBlur?: (value: string, form: FormInstance) => void;
+}
+type FormAction = "save" | "update" | "read";
+type ReadonlyProperty = boolean | ((action: FormAction, model: BaseModel) => boolean);
+type SizeModal = "small" | "large" | "xlarge" | "xxlarge" | "regular";
+interface TabModel<T extends BaseModel = BaseModel> {
+    title: string;
+    fields: FieldConfig<T>[];
+    classes?: string;
+    autorize?: boolean;
+    isVisible?: ReadonlyProperty;
+}
+interface ReusableFormProps<T extends BaseModel> {
+    fields: FieldConfig<T>[];
+    onSubmit: (values: BaseFormValues<T>) => void;
+    open: boolean;
+    isLoading: boolean;
+    onClose: () => void;
+    title: string;
+    subtitle?: string;
+    initialValues?: BaseFormValues<T>;
+}
+type APIType<T> = BaseAPI<T>;
+type BaseFormValues<T extends BaseModel, K extends keyof T = never> = Omit<T, K> & {
+    cover?: StrapiImage | File;
+};
+type BaseActionsTypes = "show" | "edit";
+declare const generateFakeFirebaseUID: () => string;
+
+declare class HelperStrapiAPI {
+    getSortingLocal<T>(values?: SorterResult<T>, defaultSorter?: string): string;
+    getPayload(object: Record<string, unknown>): FormData | {
+        data: Record<string, unknown>;
+    };
+    isFormDataEmpty(formData: FormData): boolean;
+}
+declare const helperStrapiAPI: HelperStrapiAPI;
+
+declare abstract class BaseUploaderAPI<T> extends HttpLayer {
+    protected resource?: string | undefined;
+    protected prefix?: string | undefined;
+    protected tokenKey?: string | undefined;
+    protected baseURL?: string | undefined;
+    protected endpoint: string;
+    constructor(resource?: string | undefined, prefix?: string | undefined, tokenKey?: string | undefined, baseURL?: string | undefined);
+    buildPath: (...segments: (string | undefined | null)[]) => string;
+    normalizePath: (value: string) => string;
+    abstract downloadFile(data: AnyObject[], fileNameOutput: string): Promise<void>;
+    abstract uploadStrapiFile(resource: File | Blob | File[] | Blob[], requestOptions?: RequestOptions<T>): Promise<StrapiImage[]>;
+    abstract destroyFile(id: ModelID): Promise<boolean>;
+    abstract uploadStrapiImages(fileList: UploadFile[], oldImages: StrapiImage[]): Promise<StrapiImage[]>;
+}
+
+declare class StrapiUploaderSDK<T extends BaseModel> extends BaseUploaderAPI<T> {
+    private config;
+    private defaultInvalidateKeys?;
+    constructor(resource: string, config?: StrapiConfig);
+    protected getQueryParams(opt?: RequestOptions<T>): AnyObject & {
+        filters?: AnyObject;
+    };
+    protected getRequestParams(opt?: RequestOptions<T>): RequestData;
+    uploadStrapiFile: (resource: File | Blob | File[] | Blob[], opt?: RequestOptions<T> & {
+        folder?: string;
+    }) => Promise<StrapiImage[]>;
+    destroyFile(id: number): Promise<boolean>;
+    downloadFile: (data: AnyObject[], fileName: string, optRequest?: RequestOptions<T>) => Promise<void>;
+    uploadStrapiImages: (fileList: UploadFile[], oldImages?: StrapiImage[]) => Promise<StrapiImage[]>;
+    private getInvalidateKeys;
+    useUploadImages: (opt?: InvalidateOpt) => _tanstack_react_query.UseMutationResult<StrapiImage[], Error, PayloadRequestUpload, unknown>;
+    useUploadImagesCreate: (opt?: InvalidateOpt) => _tanstack_react_query.UseMutationResult<StrapiImage[], Error, PayloadRequestUpload, unknown>;
+    uploadMergerImages: (fileList: UploadFile[], oldImages?: StrapiImage[]) => Promise<StrapiImage[]>;
+    newUploadFile: (resource: AnyValue, opt?: RequestOptions<T>, serializeOptions?: SerializeOptions) => Promise<any[]>;
+}
+
+export { type APIType, type AnyObject, type AnyValue, type AuthResponse, BaseAPI, type BaseActionsTypes, type BaseFormValues, type BaseModel, BaseUploaderAPI, type BuilderHeaders, type ConstructorWithParams, type Credentials, type FieldConfig, type FieldFilter, type FieldTag, type FieldType, type FilterParametersCustom, type FilterTypesCustom, type FormAction, type ImageFormat, type InvalidateKeysMap, type InvalidateOpt, LocalStoreManager, type MetaResponse, type ModelID, type OperatorsCustom, type Pagination, type PaginationRequest, type PaginationResponse, type PayloadRequestUpload, type PopulateParams, type RawFilter, type RawResponse, type ReadonlyProperty, type RelationCreate, type RequestData, type RequestOptions, type ReusableFormProps, type SerializeOptions, type SizeModal, type StrapiAuthResponse, type StrapiBaseInterface, type StrapiConfig, type StrapiImage, type StrapiImageFormat, type StrapiRole, StrapiSDK, StrapiUploaderSDK, type TabModel, type UserStrapiModel, buildPath, generateFakeFirebaseUID, getKeyByValue, helperStrapiAPI, isDefined, isEmptyObject, isObject, isPlainObject, publicRoutes };