@strapi/admin 5.0.0-rc.2 → 5.0.0-rc.21

package/dist/ee/server/src/controllers/authentication-utils/middlewares.d.ts

@@ -0,0 +1,9 @@
+import type { Core } from '@strapi/types';
+export declare const authenticate: Core.MiddlewareHandler;
+export declare const redirectWithAuth: Core.MiddlewareHandler;
+declare const _default: {
+    authenticate: Core.MiddlewareHandler;
+    redirectWithAuth: Core.MiddlewareHandler;
+};
+export default _default;
+//# sourceMappingURL=middlewares.d.ts.map

package/dist/ee/server/src/controllers/authentication-utils/middlewares.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middlewares.d.ts","sourceRoot":"","sources":["../../../../../../ee/server/src/controllers/authentication-utils/middlewares.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAO1C,eAAO,MAAM,YAAY,EAAE,IAAI,CAAC,iBA0B/B,CAAC;AA4DF,eAAO,MAAM,gBAAgB,EAAE,IAAI,CAAC,iBAmBnC,CAAC;;;;;AAEF,wBAGE"}

package/dist/ee/server/src/controllers/authentication-utils/utils.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="lodash" />
+export declare const getAdminStore: () => Promise<{
+    get(params?: Partial<{
+        key: string;
+        type?: string | undefined;
+        environment?: string | undefined;
+        name?: string | undefined;
+        tag?: string | undefined;
+    }> | undefined): Promise<unknown>;
+    set(params?: Partial<{
+        key: string;
+        value: unknown;
+        type?: string | undefined;
+        environment?: string | undefined;
+        name?: string | undefined;
+        tag?: string | undefined;
+    }> | undefined): Promise<void>;
+    delete(params?: Partial<{
+        key: string;
+        type?: string | undefined;
+        environment?: string | undefined;
+        name?: string | undefined;
+        tag?: string | undefined;
+    }> | undefined): Promise<void>;
+}>;
+export declare const getPrefixedRedirectUrls: () => import("lodash").Dictionary<string>;
+declare const _default: {
+    getAdminStore: () => Promise<{
+        get(params?: Partial<{
+            key: string;
+            type?: string | undefined;
+            environment?: string | undefined;
+            name?: string | undefined;
+            tag?: string | undefined;
+        }> | undefined): Promise<unknown>;
+        set(params?: Partial<{
+            key: string;
+            value: unknown;
+            type?: string | undefined;
+            environment?: string | undefined;
+            name?: string | undefined;
+            tag?: string | undefined;
+        }> | undefined): Promise<void>;
+        delete(params?: Partial<{
+            key: string;
+            type?: string | undefined;
+            environment?: string | undefined;
+            name?: string | undefined;
+            tag?: string | undefined;
+        }> | undefined): Promise<void>;
+    }>;
+    getPrefixedRedirectUrls: () => import("lodash").Dictionary<string>;
+};
+export default _default;
+//# sourceMappingURL=utils.d.ts.map

package/dist/ee/server/src/controllers/authentication-utils/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../ee/server/src/controllers/authentication-utils/utils.ts"],"names":[],"mappings":";AAQA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;EAA4D,CAAC;AAEvF,eAAO,MAAM,uBAAuB,2CAKnC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,wBAGE"}

package/dist/ee/server/src/controllers/authentication.d.ts

@@ -0,0 +1,9 @@
+import type { Context, Next } from 'koa';
+declare const _default: {
+    getProviders(ctx: Context): Promise<void>;
+    getProviderLoginOptions(ctx: Context): Promise<void>;
+    updateProviderLoginOptions(ctx: Context): Promise<void>;
+    providerLogin(ctx: Context, next: Next): any;
+};
+export default _default;
+//# sourceMappingURL=authentication.d.ts.map

package/dist/ee/server/src/controllers/authentication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authentication.d.ts","sourceRoot":"","sources":["../../../../../ee/server/src/controllers/authentication.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,KAAK,CAAC;;sBAmBf,OAAO;iCAMI,OAAO;oCASJ,OAAO;uBAmB1B,OAAO,QAAQ,IAAI;;AAnCxC,wBAgDE"}

package/dist/ee/server/src/controllers/index.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="koa" />
+declare const _default: {
+    authentication: {
+        getProviders(ctx: import("koa").Context): Promise<void>;
+        getProviderLoginOptions(ctx: import("koa").Context): Promise<void>;
+        updateProviderLoginOptions(ctx: import("koa").Context): Promise<void>;
+        providerLogin(ctx: import("koa").Context, next: import("koa").Next): any;
+    };
+    role: {
+        create(ctx: import("koa").Context): Promise<void>;
+        deleteOne(ctx: import("koa").Context): Promise<any>;
+        deleteMany(ctx: import("koa").Context): Promise<any>;
+    };
+    user: {
+        create(ctx: import("koa").Context): Promise<void>;
+        update(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+        isSSOLocked(ctx: import("koa").Context): Promise<void>;
+    };
+    admin: {
+        getProjectType(): Promise<{
+            data: {
+                isEE: boolean | undefined;
+                features: {
+                    [key: string]: any;
+                    name: string;
+                }[];
+                flags: {};
+            };
+        }>;
+        licenseLimitInformation(): Promise<{
+            data: {
+                enforcementUserCount: any;
+                currentActiveUserCount: any;
+                permittedSeats: number | null | undefined;
+                shouldNotify: boolean;
+                shouldStopCreate: boolean;
+                licenseLimitStatus: string | null;
+                isHostedOnStrapiCloud: boolean;
+                features: {
+                    [key: string]: any;
+                    name: string;
+                }[];
+            };
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/ee/server/src/controllers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../ee/server/src/controllers/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA,wBAKE"}

package/dist/ee/server/src/controllers/role.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from 'koa';
+declare const _default: {
+    /**
+     * Create a new role
+     * @param {KoaContext} ctx - koa context
+     */
+    create(ctx: Context): Promise<void>;
+    /**
+     * Delete a role
+     * @param {KoaContext} ctx - koa context
+     */
+    deleteOne(ctx: Context): Promise<any>;
+    /**
+     * delete several roles
+     * @param {KoaContext} ctx - koa context
+     */
+    deleteMany(ctx: Context): Promise<any>;
+};
+export default _default;
+//# sourceMappingURL=role.d.ts.map

package/dist/ee/server/src/controllers/role.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role.d.ts","sourceRoot":"","sources":["../../../../../ee/server/src/controllers/role.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;;IAUjC;;;OAGG;gBACe,OAAO;IAWzB;;;OAGG;mBACkB,OAAO;IAgB5B;;;OAGG;oBACmB,OAAO;;AAxC/B,wBAsDE"}

package/dist/ee/server/src/controllers/user.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from 'koa';
+declare const _default: {
+    create(ctx: Context): Promise<void>;
+    update(ctx: Context): Promise<Context | undefined>;
+    isSSOLocked(ctx: Context): Promise<void>;
+};
+export default _default;
+//# sourceMappingURL=user.d.ts.map

package/dist/ee/server/src/controllers/user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../../../ee/server/src/controllers/user.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;;gBAgCf,OAAO;gBAiCP,OAAO;qBAkCF,OAAO;;AApEhC,wBA8EE"}

package/dist/ee/server/src/destroy.d.ts

@@ -0,0 +1,6 @@
+import type { Core } from '@strapi/types';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => Promise<void>;
+export default _default;
+//# sourceMappingURL=destroy.d.ts.map

package/dist/ee/server/src/destroy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"destroy.d.ts","sourceRoot":"","sources":["../../../../ee/server/src/destroy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;qCAGR;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;AAAzD,wBAEE"}

package/dist/ee/server/src/index.d.ts

@@ -0,0 +1,380 @@
+/// <reference types="koa" />
+import { Core } from '@strapi/types';
+declare const getAdminEE: () => {
+    register: ({ strapi }: {
+        strapi: Core.Strapi;
+    }) => Promise<void>;
+    bootstrap: (args: any) => Promise<void>;
+    destroy: ({ strapi }: {
+        strapi: Core.Strapi;
+    }) => Promise<void>;
+    contentTypes: {
+        'audit-log': {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                };
+                options: {
+                    timestamps: boolean;
+                };
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    action: {
+                        type: string;
+                        required: boolean;
+                    };
+                    date: {
+                        type: string;
+                        required: boolean;
+                    };
+                    user: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                    };
+                    payload: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+    services: {
+        auth: {
+            forgotPassword: ({ email }?: any) => Promise<any>;
+            resetPassword: ({ resetPasswordToken, password }?: any) => Promise<any>;
+        };
+        passport: {
+            providerRegistry: Map<any, any>;
+            getStrategyCallbackURL: (providerName: string) => string;
+            syncProviderRegistryWithConfig: () => void;
+            authEventsMapper: {
+                onSSOAutoRegistration: string;
+                onConnectionSuccess: string;
+                onConnectionError: string;
+            };
+            getPassportStrategies: () => any[];
+        };
+        role: {
+            ssoCheckRolesIdForDeletion: (ids: any) => Promise<void>;
+        };
+        user: {
+            updateEEDisabledUsersList: (id: string, input: any) => Promise<void>;
+            removeFromEEDisabledUsersList: (ids: unknown) => Promise<void>;
+            getCurrentActiveUserCount: () => Promise<number>;
+            deleteByIds: (ids: any) => Promise<any[]>;
+            deleteById: (id: unknown) => Promise<any>;
+            updateById: (id: any, attributes: any) => Promise<any>;
+        };
+        metrics: {
+            startCron: (strapi: Core.Strapi) => void;
+            getSSOProvidersList: () => Promise<any>;
+            sendUpdateProjectInformation: (strapi: Core.Strapi) => Promise<void>;
+        };
+        'seat-enforcement': {
+            seatEnforcementWorkflow: () => Promise<void>;
+            getDisabledUserList: () => Promise<unknown>;
+        };
+    };
+    controllers: {
+        authentication: {
+            getProviders(ctx: import("koa").Context): Promise<void>;
+            getProviderLoginOptions(ctx: import("koa").Context): Promise<void>;
+            updateProviderLoginOptions(ctx: import("koa").Context): Promise<void>;
+            providerLogin(ctx: import("koa").Context, next: import("koa").Next): any;
+        };
+        role: {
+            create(ctx: import("koa").Context): Promise<void>;
+            deleteOne(ctx: import("koa").Context): Promise<any>;
+            deleteMany(ctx: import("koa").Context): Promise<any>;
+        };
+        user: {
+            create(ctx: import("koa").Context): Promise<void>;
+            update(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+            isSSOLocked(ctx: import("koa").Context): Promise<void>;
+        };
+        admin: {
+            getProjectType(): Promise<{
+                data: {
+                    isEE: boolean | undefined;
+                    features: {
+                        [key: string]: any;
+                        name: string;
+                    }[];
+                    flags: {};
+                };
+            }>;
+            licenseLimitInformation(): Promise<{
+                data: {
+                    enforcementUserCount: any;
+                    currentActiveUserCount: any;
+                    permittedSeats: number | null | undefined;
+                    shouldNotify: boolean;
+                    shouldStopCreate: boolean;
+                    licenseLimitStatus: string | null;
+                    isHostedOnStrapiCloud: boolean;
+                    features: {
+                        [key: string]: any;
+                        name: string;
+                    }[];
+                };
+            }>;
+        };
+    };
+    routes: {
+        sso: {
+            type: string;
+            routes: ({
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    middlewares: Core.MiddlewareHandler[];
+                    auth: boolean;
+                    policies?: undefined;
+                };
+            } | {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    middlewares: Core.MiddlewareHandler[];
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                    auth?: undefined;
+                };
+            })[];
+        };
+        'license-limit': {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                };
+            }[];
+        };
+    };
+} | {
+    controllers: {
+        'audit-logs': {
+            findMany(ctx: import("koa").Context): Promise<void>;
+            findOne(ctx: import("koa").Context): Promise<void>;
+        };
+        authentication: {
+            getProviders(ctx: import("koa").Context): Promise<void>;
+            getProviderLoginOptions(ctx: import("koa").Context): Promise<void>;
+            updateProviderLoginOptions(ctx: import("koa").Context): Promise<void>;
+            providerLogin(ctx: import("koa").Context, next: import("koa").Next): any;
+        };
+        role: {
+            create(ctx: import("koa").Context): Promise<void>;
+            deleteOne(ctx: import("koa").Context): Promise<any>;
+            deleteMany(ctx: import("koa").Context): Promise<any>;
+        };
+        user: {
+            create(ctx: import("koa").Context): Promise<void>;
+            update(ctx: import("koa").Context): Promise<import("koa").Context | undefined>;
+            isSSOLocked(ctx: import("koa").Context): Promise<void>;
+        };
+        admin: {
+            getProjectType(): Promise<{
+                data: {
+                    isEE: boolean | undefined;
+                    features: {
+                        [key: string]: any;
+                        name: string;
+                    }[];
+                    flags: {};
+                };
+            }>;
+            licenseLimitInformation(): Promise<{
+                data: {
+                    enforcementUserCount: any;
+                    currentActiveUserCount: any;
+                    permittedSeats: number | null | undefined;
+                    shouldNotify: boolean;
+                    shouldStopCreate: boolean;
+                    licenseLimitStatus: string | null;
+                    isHostedOnStrapiCloud: boolean;
+                    features: {
+                        [key: string]: any;
+                        name: string;
+                    }[];
+                };
+            }>;
+        };
+    };
+    routes: {
+        'audit-logs': {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    middlewares: Core.MiddlewareHandler[];
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                };
+            }[];
+        };
+        sso: {
+            type: string;
+            routes: ({
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    middlewares: Core.MiddlewareHandler[];
+                    auth: boolean;
+                    policies?: undefined;
+                };
+            } | {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    middlewares: Core.MiddlewareHandler[];
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                    auth?: undefined;
+                };
+            })[];
+        };
+        'license-limit': {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                };
+            }[];
+        };
+    };
+    register({ strapi }: {
+        strapi: Core.Strapi;
+    }): Promise<void>;
+    destroy({ strapi }: {
+        strapi: Core.Strapi;
+    }): Promise<void>;
+    bootstrap: (args: any) => Promise<void>;
+    contentTypes: {
+        'audit-log': {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                };
+                options: {
+                    timestamps: boolean;
+                };
+                pluginOptions: {
+                    'content-manager': {
+                        visible: boolean;
+                    };
+                    'content-type-builder': {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    action: {
+                        type: string;
+                        required: boolean;
+                    };
+                    date: {
+                        type: string;
+                        required: boolean;
+                    };
+                    user: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                    };
+                    payload: {
+                        type: string;
+                    };
+                };
+            };
+        };
+    };
+    services: {
+        auth: {
+            forgotPassword: ({ email }?: any) => Promise<any>;
+            resetPassword: ({ resetPasswordToken, password }?: any) => Promise<any>;
+        };
+        passport: {
+            providerRegistry: Map<any, any>;
+            getStrategyCallbackURL: (providerName: string) => string;
+            syncProviderRegistryWithConfig: () => void;
+            authEventsMapper: {
+                onSSOAutoRegistration: string;
+                onConnectionSuccess: string;
+                onConnectionError: string;
+            };
+            getPassportStrategies: () => any[];
+        };
+        role: {
+            ssoCheckRolesIdForDeletion: (ids: any) => Promise<void>;
+        };
+        user: {
+            updateEEDisabledUsersList: (id: string, input: any) => Promise<void>;
+            removeFromEEDisabledUsersList: (ids: unknown) => Promise<void>;
+            getCurrentActiveUserCount: () => Promise<number>;
+            deleteByIds: (ids: any) => Promise<any[]>;
+            deleteById: (id: unknown) => Promise<any>;
+            updateById: (id: any, attributes: any) => Promise<any>;
+        };
+        metrics: {
+            startCron: (strapi: Core.Strapi) => void;
+            getSSOProvidersList: () => Promise<any>;
+            sendUpdateProjectInformation: (strapi: Core.Strapi) => Promise<void>;
+        };
+        'seat-enforcement': {
+            seatEnforcementWorkflow: () => Promise<void>;
+            getDisabledUserList: () => Promise<unknown>;
+        };
+    };
+};
+export default getAdminEE;
+//# sourceMappingURL=index.d.ts.map

package/dist/ee/server/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../ee/server/src/index.ts"],"names":[],"mappings":";AAYA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA8BiB;QAAE,MAAM,EAAE,KAAK,MAAM,CAAA;KAAE;wBAWxB;QAAE,MAAM,EAAE,KAAK,MAAM,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQtD,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/ee/server/src/register.d.ts

@@ -0,0 +1,6 @@
+import type { Core } from '@strapi/types';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => Promise<void>;
+export default _default;
+//# sourceMappingURL=register.d.ts.map

package/dist/ee/server/src/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../ee/server/src/register.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;qCAIR;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;AAAzD,wBAEE"}

package/dist/ee/server/src/routes/index.d.ts

@@ -0,0 +1,47 @@
+declare const _default: {
+    sso: {
+        type: string;
+        routes: ({
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                middlewares: import("@strapi/types/dist/core").MiddlewareHandler[];
+                auth: boolean;
+                policies?: undefined;
+            };
+        } | {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                middlewares: import("@strapi/types/dist/core").MiddlewareHandler[];
+                policies: (string | {
+                    name: string;
+                    config: {
+                        actions: string[];
+                    };
+                })[];
+                auth?: undefined;
+            };
+        })[];
+    };
+    'license-limit': {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: (string | {
+                    name: string;
+                    config: {
+                        actions: string[];
+                    };
+                })[];
+            };
+        }[];
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/ee/server/src/routes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../ee/server/src/routes/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,wBAGE"}

package/dist/ee/server/src/routes/license-limit.d.ts

@@ -0,0 +1,18 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: (string | {
+                name: string;
+                config: {
+                    actions: string[];
+                };
+            })[];
+        };
+    }[];
+};
+export default _default;
+//# sourceMappingURL=license-limit.d.ts.map

package/dist/ee/server/src/routes/license-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"license-limit.d.ts","sourceRoot":"","sources":["../../../../../ee/server/src/routes/license-limit.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wBA0BE"}