@ezpaarse-project/ezreeport-sdk-js 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/{types → dist/dist/types/src}/modules/reports.d.ts

@@ -1,6 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
 import { Stream } from 'stream';
 import { type Period, type RawPeriod } from '../lib/utils';
-import { getJob, type FullJob, type Job } from './queues';
+import { type FullJob, type Job, type Queue } from './queues';
 import type { RawFullTask } from './tasks';
 interface RawReportResultDetail {
     createdAt: string;
@@ -19,6 +21,11 @@ interface RawReportResultDetail {
     error?: {
         message: string;
         stack: string[];
+        cause?: {
+            type: string;
+            layout: number;
+            figure?: number;
+        };
     };
     meta?: unknown;
 }
@@ -46,15 +53,15 @@ type FullReportJob = FullJob<RawReportData, RawReportResult>;
 /**
  * Start generation of a report
  *
- * Needs `namespaces[namespaceId].tasks-post-task-run` permission
+ * Needs `namespaces[namespaceId].tasks-post-task-_run` permission
  *
- * @param taskId Id of the task
+ * @param taskOrId Task or id of the task
  * @param params Other params for overriding default
  * @param namespaces
  *
  * @returns Job info to track progress
  */
-export declare const startGeneration: (taskId: RawFullTask['id'], params?: {
+export declare const startGeneration: (taskOrId: RawFullTask | RawFullTask['id'], params?: {
     /**
      * Override targets of task. Also enable first level of debugging
      * (disable generation history)
@@ -73,13 +80,17 @@ export type GenerationProgressEvent = {
     progress: number;
     status: FullReportJob['status'];
 };
+type GenerationEvents = {
+    'started': [GenerationStartedEvent];
+    'progress': [GenerationProgressEvent];
+};
 /**
  * Start generation of a report and track progress
  *
  * Needs `namespaces[namespaceId].tasks-post-task-run`
  * & `namespaces[namespaceId].queues-get-queue-jobs-jobId` permissions
  *
- * @param taskId Id of the task
+ * @param taskOrId Task or id of the task
  * @param params Other params for overriding default
  * @param namespaces
  *
@@ -91,7 +102,7 @@ export type GenerationProgressEvent = {
  *
  * @returns When generation ends, with detail
  */
-export declare const startAndListenGeneration: (taskId: string, params?: {
+export declare const startAndListenGeneration: (taskOrId: string | RawFullTask, params?: {
     /**
      * Override targets of task. Also enable first level of debugging
      * (disable generation history)
@@ -101,7 +112,7 @@ export declare const startAndListenGeneration: (taskId: string, params?: {
      * Override period, must match task's recurrence
      */
     period?: Period | undefined;
-} | undefined, namespaces?: string[] | undefined) => import("../lib/promises").EventfulPromise<ReportResult>;
+} | undefined, namespaces?: string[] | undefined) => import("../lib/promises").EventfulPromise<ReportResult, GenerationEvents>;
 interface ResponseTypeMap {
     arraybuffer: ArrayBuffer;
     blob: Blob;
@@ -109,7 +120,6 @@ interface ResponseTypeMap {
     text: string;
     stream: Stream;
 }
-type GetJobParams = Parameters<typeof getJob>;
 /**
  * Get report main file (the result) by giving the report's name
  *
@@ -129,14 +139,14 @@ export declare const getReportFileByName: <Result extends keyof ResponseTypeMap
  * Needs `namespaces[namespaceId].reports-get-year-yearMonth-filename`
  * & `namespaces[namespaceId].queues-get-queue-jobs-jobId ` permission
  *
- * @param queueName Name of queue where job is
- * @param jobId Id of the job in queue
+ * @param queueOrName Queue or queue's name where job is
+ * @param jobOrId Job or job's id in queue
  * @param namespaces
  * @param responseType Wanted response type
  *
  * @returns The report's content
  */
-export declare const getReportFileByJob: <Result extends keyof ResponseTypeMap = "text">(queueName: GetJobParams[0], jobId: GetJobParams[1], namespaces?: GetJobParams[2], responseType?: Result | undefined) => Promise<ResponseTypeMap[Result]>;
+export declare const getReportFileByJob: <Result extends keyof ResponseTypeMap = "text">(queueName: Queue | Queue['name'], jobId: Job<RawReportData> | Job<RawReportData>['id'], namespaces?: string[], responseType?: Result | undefined) => Promise<ResponseTypeMap[Result]>;
 /**
  * Get report detail by giving the report's name
  *
@@ -156,15 +166,15 @@ export declare const getReportDetailByName: (name: string, namespaces?: string[]
  * Needs `namespaces[namespaceId].reports-get-year-yearMonth-filename`
  * & `namespaces[namespaceId].queues-get-queue-jobs-jobId` permission
  *
- * @param queueName Name of queue where job is
- * @param jobId Id of the job in queue
+ * @param queueOrName Queue or queue's name where job is
+ * @param jobOrId Job or job's id in queue
  * @param namespaces
  * @param responseType Wanted response type. **If provided with anything but `json` you will have to
  * cast in your type to avoid auto-completion issues.**
  *
  * @returns The detail's content
  */
-export declare const getReportDetailByJob: (queueName: GetJobParams[0], jobId: GetJobParams[1], namespaces?: GetJobParams[2], responseType?: keyof ResponseTypeMap) => Promise<ReportResult>;
+export declare const getReportDetailByJob: (queueName: Queue | Queue['name'], jobId: Job<RawReportData> | Job<RawReportData>['id'], namespaces?: string[], responseType?: keyof ResponseTypeMap) => Promise<ReportResult>;
 /**
  * Get report debug file by giving the report's name
  *
@@ -183,12 +193,12 @@ export declare const getReportDebugByName: <Result extends keyof ResponseTypeMap
  * Needs `namespaces[namespaceId].reports-get-year-yearMonth-filename`
  * & `namespaces[namespaceId].queues-get-queue-jobs-jobId ` permission
  *
- * @param queueName Name of queue where job is
- * @param jobId Id of the job in queue
+ * @param queueOrName Queue or queue's name where job is
+ * @param jobOrId Job or job's id in queue
  * @param namespaces
  * @param responseType Wanted response type
  *
  * @returns The debug's content
  */
-export declare const getReportDebugByJob: <Result extends keyof ResponseTypeMap = "json">(queueName: GetJobParams[0], jobId: GetJobParams[1], namespaces?: GetJobParams[2], responseType?: Result | undefined) => Promise<ResponseTypeMap[Result]>;
+export declare const getReportDebugByJob: <Result extends keyof ResponseTypeMap = "json">(queueName: Queue | Queue['name'], jobId: Job<RawReportData> | Job<RawReportData>['id'], namespaces?: string[], responseType?: Result | undefined) => Promise<ResponseTypeMap[Result]>;
 export {};

package/dist/dist/dist/types/src/modules/tasks.d.ts

@@ -0,0 +1,243 @@
+import { type ApiResponse, type PaginatedApiResponse } from '../lib/axios';
+import type { PaginationOpts } from '../lib/utils';
+import { type Activity, type RawActivity } from './tasksActivity';
+import type { Namespace } from './namespaces';
+import { type Layout, type RawTemplate, type Template } from './templates';
+import { type Task, type RawTaskWithNamespace, type TaskWithNamespace } from './tasks.base';
+interface AdditionalRawTaskData {
+    template: {
+        fetchOptions?: {
+            filters?: Record<string, any>;
+            dateField?: string;
+            index: string;
+        };
+        inserts?: (Layout & {
+            at: number;
+        })[];
+    };
+    extends: RawTemplate;
+    lastExtended?: {
+        id: string;
+        tags: RawTemplate['tags'];
+    };
+    targets: string[];
+    activity: RawActivity[];
+}
+interface AdditionalTaskData extends Omit<AdditionalRawTaskData, 'activity' | 'extends' | 'lastExtended'> {
+    activity: Activity[];
+    extends: Template;
+    lastExtended?: {
+        id: Template['id'];
+        name: Template['name'];
+        tags: Template['tags'];
+    };
+}
+export interface RawFullTask extends RawTaskWithNamespace, AdditionalRawTaskData {
+}
+export interface FullTask extends TaskWithNamespace, AdditionalTaskData {
+}
+/**
+ * Input data for creating a new task
+ */
+export interface InputTask extends Pick<FullTask, 'name' | 'template' | 'targets' | 'recurrence'> {
+    namespace?: Task['namespaceId'];
+    nextRun?: FullTask['nextRun'];
+    enabled?: FullTask['enabled'];
+    extends: string;
+}
+/**
+ * Partial input data for creating a new task with a preset
+ */
+export interface PartialInputTask extends Pick<InputTask, 'targets' | 'name' | 'namespace'>, Partial<Omit<InputTask, 'targets' | 'name' | 'namespace' | 'template'>> {
+    template: Pick<InputTask['template'], 'fetchOptions'>;
+}
+export type TaskList = (Task & {
+    tags: Template['tags'];
+    _count: {
+        targets: number;
+    };
+})[];
+/**
+ * Get all available tasks
+ *
+ * Needs `namespaces[namespaceId].tasks-get` permission
+ *
+ * @param paginationOpts Options for pagination
+ * @param namespaces
+ *
+ * @returns All tasks' info
+ */
+export declare const getAllTasks: (paginationOpts?: PaginationOpts, namespaces?: Namespace['id'][]) => Promise<PaginatedApiResponse<TaskList[number], 'id'>>;
+/**
+ * Get targets of available tasks
+ *
+ * Needs `namespaces[namespaceId].tasks-get-_targets` permission
+ *
+ * @param namespaces
+ *
+ * @returns Targets' email
+ */
+export declare const getAllTargets: (namespaces?: Namespace['id'][]) => Promise<ApiResponse<string[]>>;
+/**
+ * Get available tasks of specific target
+ *
+ * Needs `namespaces[namespaceId].tasks-get-_targets-email-tasks` permission
+ *
+ * @param email The email of the target
+ * @param namespaces
+ *
+ * @returns Tasks where given email is a target
+ */
+export declare const getTasksOfTarget: (email: string, namespaces?: Namespace['id'][]) => Promise<{
+    content: {
+        nextRun: Date;
+        lastRun?: Date | undefined;
+        createdAt: Date;
+        updatedAt?: Date | undefined;
+        name: string;
+        id: string;
+        namespaceId: string;
+        recurrence: import("./tasks.base").Recurrence;
+        enabled: boolean;
+        tags: {
+            name: string;
+            color?: string | undefined;
+        }[];
+    }[];
+    status: {
+        code: number;
+        message: string;
+    };
+}>;
+/**
+ * Unsubscribe a target from a task
+ *
+ * Needs `namespaces[namespaceId].tasks-get-_targets-email-tasks` permission
+ *
+ * @param email The email of the target
+ * @param taskOrId Task or Task's id
+ * @param namespaces
+ */
+export declare const unsubTargetOfTask: (email: string, taskOrId: Task | Task['id'], namespaces?: Namespace['id'][]) => Promise<void>;
+/**
+ * Create a new task
+ *
+ * Needs `namespaces[namespaceId].tasks-post` permission
+ *
+ * @param task Task's data
+ * @param namespaces
+ *
+ * @returns Created task's info
+ */
+export declare const createTask: (task: InputTask, namespaces?: Namespace['id'][]) => Promise<ApiResponse<FullTask>>;
+/**
+ * Creates a new task from a preset
+ *
+ * Needs `namespaces[namespaceId].tasks-post-_from-preset-presetId` permission
+ *
+ * @param presetId The ID of the preset.
+ * @param partialTask The partial input task.
+ * @param namespaces
+ *
+ * @returns Created task's info
+ */
+export declare const createTaskFromPreset: (presetId: string, partialTask: PartialInputTask, namespaces?: Namespace['id'][]) => Promise<ApiResponse<FullTask>>;
+/**
+ * Get task info
+ *
+ * Needs `namespaces[namespaceId].tasks-get-task` permission
+ *
+ * @param taskOrId Task or Task's id
+ * @param namespaces
+ *
+ * @returns Task's info
+ */
+export declare const getTask: (taskOrId: Task | Task['id'], namespaces?: Namespace['id'][]) => Promise<ApiResponse<FullTask>>;
+/**
+ * Update or create a task
+ *
+ * Needs `namespaces[namespaceId].tasks-put-task` permission
+ *
+ * @param task Task's data **with id**
+ * @param namespaces
+ *
+ * @returns Updated/Created Task's info
+ */
+export declare const upsertTask: (task: InputTask & {
+    id: Task['id'];
+}, namespaces?: Namespace['id'][]) => Promise<ApiResponse<FullTask>>;
+/**
+ * Update a task
+ *
+ * Needs `namespaces[namespaceId].tasks-put-task` permission
+ *
+ * @param task Task's data **with id**
+ * @param namespaces
+ *
+ * @deprecated Use `upsertTask` instead
+ *
+ * @returns Updated Task's info
+ */
+export declare const updateTask: (task: InputTask & {
+    id: Task['id'];
+}, namespaces?: Namespace['id'][]) => Promise<ApiResponse<FullTask>>;
+/**
+ * Delete a task
+ *
+ * Needs `namespaces[namespaceId].tasks-delete-task` permission
+ *
+ * @param taskOrId Task or Task's id
+ * @param namespaces
+ */
+export declare const deleteTask: (taskOrId: Task | Task['id'], namespaces?: Namespace['id'][]) => Promise<void>;
+/**
+ * Shorthand to enable task
+ *
+ * Needs `namespaces[namespaceId].tasks-put-_task-enable` permission
+ *
+ * @param taskOrId Task or Task's id
+ * @param namespaces
+ *
+ * @returns Updated task's info
+ */
+export declare const enableTask: (taskOrId: Task | Task['id'], namespaces?: Namespace['id'][]) => Promise<ApiResponse<FullTask>>;
+/**
+ * Shorthand to disable task
+ *
+ * Needs `namespaces[namespaceId].tasks-put-_task-disable` permission
+ *
+ * @param taskOrId Task or Task's id
+ * @param namespaces
+ *
+ * @returns Updated task's info
+ */
+export declare const disableTask: (taskOrId: Task | Task['id'], namespaces?: Namespace['id'][]) => Promise<ApiResponse<FullTask>>;
+/**
+ * Link a task to a template
+ *
+ * Needs `namespaces[namespaceId].tasks-put-task-_link-template` permission
+ *
+ * @param taskOrId Task or Task's id
+ * @param templateOrId Template or Template's id
+ * @param namespaces
+ *
+ * @returns Updated task's info
+ */
+export declare const linkTaskToTemplate: (taskOrId: Task | Task['id'], templateOrId: Template | Template['id'], namespaces?: Namespace['id'][]) => Promise<{
+    content: FullTask;
+    status: {
+        code: number;
+        message: string;
+    };
+}>;
+/**
+ * Unlink a task to a template
+ *
+ * Needs `namespaces[namespaceId].tasks-delete-task-_link-template` permission
+ *
+ * @param taskOrId Task or Task's id
+ * @param templateOrId Template or Template's id
+ * @param namespaces
+ */
+export declare const unlinkTaskToTemplate: (taskOrId: Task | Task['id'], templateOrId: Template | Template['id'], namespaces?: Namespace['id'][]) => Promise<void>;
+export {};

package/dist/dist/dist/types/src/modules/tasks.public.d.ts

@@ -0,0 +1,2 @@
+export { type FullTask, type InputTask, type PartialInputTask, type TaskList, getAllTasks, getAllTargets, getTasksOfTarget, unsubTargetOfTask, getTask, createTask, createTaskFromPreset, updateTask, upsertTask, deleteTask, enableTask, disableTask, linkTaskToTemplate, unlinkTaskToTemplate, } from './tasks';
+export { Recurrence, type Task, type TaskWithNamespace, } from './tasks.base';

package/dist/dist/dist/types/src/modules/tasksActivity.d.ts

@@ -0,0 +1,36 @@
+import { type PaginatedApiResponse } from '../lib/axios';
+import type { PaginationOpts } from '../lib/utils';
+import { type TaskWithNamespace } from './tasks.base';
+export interface RawActivity {
+    id: string;
+    taskId: string;
+    type: string;
+    message: string;
+    data?: object;
+    createdAt: string;
+}
+export interface Activity extends Omit<RawActivity, 'createdAt'> {
+    createdAt: Date;
+}
+export interface ActivityWithTask extends Omit<Activity, 'taskId'> {
+    task: TaskWithNamespace;
+}
+/**
+ * Transform raw data from JSON, to JS usable data
+ *
+ * @param entry Raw history entry
+ *
+ * @returns Parsed history entry
+ */
+export declare const parseActivity: (entry: RawActivity) => Activity;
+/**
+ * Get all available history entries
+ *
+ * Needs `namespaces[namespaceId].history-get` permission
+ *
+ * @param paginationOpts Options for pagination
+ * @param namespaces
+ *
+ * @returns All history entries' info
+ */
+export declare const getAllEntries: (paginationOpts?: PaginationOpts, namespaces?: string[]) => Promise<PaginatedApiResponse<ActivityWithTask, 'id'>>;

package/dist/dist/dist/types/src/modules/tasksActivity.public.d.ts

@@ -0,0 +1,5 @@
+export { 
+/** @deprecated Use `Activity` instead */
+type Activity as History, 
+/** @deprecated Use `ActivityWithTask` instead */
+type ActivityWithTask as HistoryWithTask, type Activity, type ActivityWithTask, getAllEntries, } from './tasksActivity';

package/dist/dist/dist/types/src/modules/tasksPresets.d.ts

@@ -0,0 +1,83 @@
+import type { Recurrence } from './tasks.base';
+import type { FullTemplate } from './templates';
+import { type ApiResponse } from '../lib/axios';
+interface RawTasksPreset {
+    id: string;
+    name: string;
+    recurrence: Recurrence;
+    tags: {
+        name: string;
+        color?: string;
+    }[];
+    createdAt: string;
+    updatedAt?: string;
+}
+export interface TasksPreset extends Omit<RawTasksPreset, 'createdAt' | 'updatedAt'> {
+    createdAt: Date;
+    updatedAt?: Date;
+}
+export interface RawFullTasksPreset extends Omit<RawTasksPreset, 'tags'> {
+    fetchOptions?: {
+        dateField?: string;
+    };
+    template: Pick<FullTemplate, 'id' | 'name' | 'tags' | 'createdAt' | 'updatedAt'>;
+}
+export interface FullTasksPreset extends Omit<RawFullTasksPreset, 'createdAt' | 'updatedAt'> {
+    createdAt: Date;
+    updatedAt?: Date;
+}
+export interface InputTasksPreset extends Pick<FullTasksPreset, 'name' | 'fetchOptions' | 'recurrence'> {
+    template: string;
+}
+/**
+ * Get all available tasks presets
+ *
+ * Needs `general.tasks-presets-get` permission
+ *
+ * @returns All presets' info
+ */
+export declare const getAllTasksPresets: () => Promise<ApiResponse<TasksPreset[]>>;
+/**
+ * Get tasks preset info
+ *
+ * Needs `general.tasks-presets-get-preset` permission
+ *
+ * @param presetOrId Preset or Preset's id
+ *
+ * @returns Preset info
+ */
+export declare const getTasksPreset: (presetOrId: TasksPreset | TasksPreset['id']) => Promise<ApiResponse<FullTasksPreset>>;
+/**
+ * Create a new tasks preset
+ *
+ * Needs `general.tasks-presets-post` permission
+ *
+ * @param preset Preset's data
+ * @param namespaces
+ *
+ * @returns Created preset's info
+ */
+export declare const createTasksPreset: (preset: InputTasksPreset) => Promise<ApiResponse<FullTasksPreset>>;
+/**
+ * Update or create a tasks preset
+ *
+ * Needs `general.tasks-presets-put-preset` permission
+ *
+ * @param preset Preset's data **with id**
+ * @param namespaces
+ *
+ * @returns Updated/Created Preset's info
+ */
+export declare const upsertTasksPreset: (preset: InputTasksPreset & {
+    id: TasksPreset['id'];
+}) => Promise<ApiResponse<FullTasksPreset>>;
+/**
+ * Delete a tasks preset
+ *
+ * Needs `general.tasks-presets-delete-preset` permission
+ *
+ * @param presetOrId Preset or Preset's id
+ * @param namespaces
+ */
+export declare const deleteTasksPreset: (presetOrId: TasksPreset | TasksPreset['id']) => Promise<void>;
+export {};

package/dist/dist/dist/types/src/modules/tasksPresets.public.d.ts

@@ -0,0 +1 @@
+export { type TasksPreset, type FullTasksPreset, type InputTasksPreset, getAllTasksPresets, getTasksPreset, createTasksPreset, upsertTasksPreset, deleteTasksPreset, } from './tasksPresets';

package/dist/dist/dist/types/src/modules/templates.d.ts

@@ -0,0 +1,153 @@
+import { type ApiResponse } from '../lib/axios';
+import { type RawTask, type Task } from './tasks.base';
+interface FigureFetchOptions {
+    fetchCount?: string;
+    filters?: Record<string, any>;
+}
+interface FigureFetchOptionsAggs extends FigureFetchOptions {
+    aggs?: Record<string, any>[];
+}
+interface FigureFetchOptionsBuckets extends FigureFetchOptions {
+    buckets?: Record<string, any>[];
+    metric?: Record<string, any>;
+}
+export interface Figure {
+    type: string;
+    data?: string | unknown[];
+    params: Record<string, any>;
+    fetchOptions?: FigureFetchOptionsAggs | FigureFetchOptionsBuckets;
+    slots?: number[];
+}
+export interface Layout {
+    data?: unknown;
+    fetcher?: string;
+    fetchOptions?: {
+        fetchCount?: string;
+        filters?: Record<string, any>;
+    };
+    figures: Figure[];
+}
+export interface RawTemplate {
+    id: string;
+    name: string;
+    pageCount: number;
+    tags: {
+        name: string;
+        color?: string;
+    }[];
+    createdAt: string;
+    updatedAt?: string;
+}
+export interface Template extends Omit<RawTemplate, 'createdAt' | 'updatedAt'> {
+    createdAt: Date;
+    updatedAt?: Date;
+}
+/**
+ * Transform raw data from JSON, to JS usable data
+ *
+ * @param template Raw template
+ *
+ * @returns Parsed template
+ */
+export declare const parseTemplate: (template: RawTemplate) => Template;
+export interface RawFullTemplate extends RawTemplate {
+    body: {
+        renderer?: string;
+        renderOptions?: {
+            grid?: {
+                cols: number;
+                rows: number;
+            };
+        };
+        fetchOptions?: {
+            filters?: Record<string, any>;
+            index?: string;
+            dateField: string;
+        };
+        layouts: Layout[];
+    };
+    tasks: RawTask[];
+}
+export interface FullTemplate extends Omit<RawFullTemplate, 'tasks' | 'createdAt' | 'updatedAt'> {
+    createdAt: Date;
+    updatedAt?: Date;
+    tasks: Task[];
+}
+export interface InputTemplate {
+    name: FullTemplate['name'];
+    body: FullTemplate['body'];
+    tags: FullTemplate['tags'];
+}
+type TemplateListResponse = ApiResponse<Template[]> & {
+    meta: {
+        default: string;
+    };
+};
+/**
+ * Get all available templates
+ *
+ * Needs `general.templates-get` permission
+ *
+ * @returns All templates' info
+ */
+export declare const getAllTemplates: () => Promise<TemplateListResponse>;
+/**
+ * Get template info
+ *
+ * Needs `general.templates-get-template` permission
+ *
+ * @param templateOrId Template or Template's id
+ *
+ * @returns Template info
+ */
+export declare const getTemplate: (templateOrId: Template | Template['id']) => Promise<ApiResponse<FullTemplate>>;
+/**
+ * Create a new template
+ *
+ * Needs `general.templates-post` permission
+ *
+ * @param template Template's data
+ * @param namespaces
+ *
+ * @returns Created template's info
+ */
+export declare const createTemplate: (template: InputTemplate) => Promise<ApiResponse<FullTemplate>>;
+/**
+ * Update or create a template
+ *
+ * Needs `general.templates-put-template` permission
+ *
+ * @param template Template's data **with id**
+ * @param namespaces
+ *
+ * @returns Updated/Created Template's info
+ */
+export declare const upsertTemplate: (template: InputTemplate & {
+    id: Template['id'];
+}) => Promise<ApiResponse<FullTemplate>>;
+/**
+ * Update a template
+ *
+ * Needs `general.templates-put-template` permission
+ *
+ * @param id Template's id
+ * @param template New Template's data
+ * @param namespaces
+ *
+ * @deprecated use `upsertTemplate` instead
+ *
+ * @returns Updated Template's info
+ */
+export declare const updateTemplate: (template: InputTemplate & {
+    id: Template['id'];
+}) => Promise<ApiResponse<FullTemplate>>;
+/**
+ * Delete a template
+ *
+ * Needs `general.templates-delete-template` permission
+ *
+ * @param templateOrId Template or Template's id
+ * @param namespaces
+ */
+export declare const deleteTemplate: (templateOrId: Template | Template['id']) => Promise<void>;
+export {};