windmill-cli 1.423.1 → 1.426.0

package/esm/gen/services.gen.js

@@ -139,7 +139,7 @@ export const logout = () => {
 export const getUser = (data) => {
     return __request(OpenAPI, {
         method: 'GET',
-        url: '/w/{workspace}/users/{username}',
+        url: '/w/{workspace}/users/get/{username}',
         path: {
             workspace: data.workspace,
             username: data.username
@@ -200,6 +200,44 @@ export const setPassword = (data) => {
         mediaType: 'application/json'
     });
 };
+/**
+ * set password for a specific user (require super admin)
+ * @param data The data for the request.
+ * @param data.user
+ * @param data.requestBody set password
+ * @returns string password set
+ * @throws ApiError
+ */
+export const setPasswordForUser = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/users/set_password_of/{user}',
+        path: {
+            user: data.user
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
+/**
+ * set login type for a specific user (require super admin)
+ * @param data The data for the request.
+ * @param data.user
+ * @param data.requestBody set login type
+ * @returns string login type set
+ * @throws ApiError
+ */
+export const setLoginTypeForUser = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/users/set_login_type/{user}',
+        path: {
+            user: data.user
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
 /**
  * create user
  * @param data The data for the request.
@@ -1851,6 +1889,83 @@ export const listContextualVariables = (data) => {
         }
     });
 };
+/**
+ * Get all critical alerts for this workspace
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.page
+ * @param data.pageSize
+ * @param data.acknowledged
+ * @returns CriticalAlert Successfully retrieved all critical alerts
+ * @throws ApiError
+ */
+export const workspaceGetCriticalAlerts = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/workspaces/critical_alerts',
+        path: {
+            workspace: data.workspace
+        },
+        query: {
+            page: data.page,
+            page_size: data.pageSize,
+            acknowledged: data.acknowledged
+        }
+    });
+};
+/**
+ * Acknowledge a critical alert for this workspace
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.id The ID of the critical alert to acknowledge
+ * @returns string Successfully acknowledged the critical alert
+ * @throws ApiError
+ */
+export const workspaceAcknowledgeCriticalAlert = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/workspaces/critical_alerts/{id}/acknowledge',
+        path: {
+            workspace: data.workspace,
+            id: data.id
+        }
+    });
+};
+/**
+ * Acknowledge all unacknowledged critical alerts for this workspace
+ * @param data The data for the request.
+ * @param data.workspace
+ * @returns string Successfully acknowledged all unacknowledged critical alerts.
+ * @throws ApiError
+ */
+export const workspaceAcknowledgeAllCriticalAlerts = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/workspaces/critical_alerts/acknowledge_all',
+        path: {
+            workspace: data.workspace
+        }
+    });
+};
+/**
+ * Mute critical alert UI for this workspace
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.requestBody Boolean flag to mute critical alerts.
+ * @returns string Successfully updated mute critical alert settings.
+ * @throws ApiError
+ */
+export const workspaceMuteCriticalAlertsUi = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/workspaces/critical_alerts/mute',
+        path: {
+            workspace: data.workspace
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
 /**
  * login with oauth authorization flow
  * @param data The data for the request.
@@ -4473,6 +4588,32 @@ export const getCompletedCount = (data) => {
         }
     });
 };
+/**
+ * count number of completed jobs with filter
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.completedAfterSAgo
+ * @param data.success
+ * @param data.tags
+ * @param data.allWorkspaces
+ * @returns number Count of completed jobs
+ * @throws ApiError
+ */
+export const countCompletedJobs = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/jobs/completed/count_jobs',
+        path: {
+            workspace: data.workspace
+        },
+        query: {
+            completed_after_s_ago: data.completedAfterSAgo,
+            success: data.success,
+            tags: data.tags,
+            all_workspaces: data.allWorkspaces
+        }
+    });
+};
 /**
  * get the ids of all jobs matching the given filters
  * @param data The data for the request.
@@ -5743,6 +5884,149 @@ export const setWebsocketTriggerEnabled = (data) => {
         mediaType: 'application/json'
     });
 };
+/**
+ * create kafka trigger
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.requestBody new kafka trigger
+ * @returns string kafka trigger created
+ * @throws ApiError
+ */
+export const createKafkaTrigger = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/kafka_triggers/create',
+        path: {
+            workspace: data.workspace
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
+/**
+ * update kafka trigger
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.path
+ * @param data.requestBody updated trigger
+ * @returns string kafka trigger updated
+ * @throws ApiError
+ */
+export const updateKafkaTrigger = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/kafka_triggers/update/{path}',
+        path: {
+            workspace: data.workspace,
+            path: data.path
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
+/**
+ * delete kafka trigger
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.path
+ * @returns string kafka trigger deleted
+ * @throws ApiError
+ */
+export const deleteKafkaTrigger = (data) => {
+    return __request(OpenAPI, {
+        method: 'DELETE',
+        url: '/w/{workspace}/kafka_triggers/delete/{path}',
+        path: {
+            workspace: data.workspace,
+            path: data.path
+        }
+    });
+};
+/**
+ * get kafka trigger
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.path
+ * @returns KafkaTrigger kafka trigger deleted
+ * @throws ApiError
+ */
+export const getKafkaTrigger = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/kafka_triggers/get/{path}',
+        path: {
+            workspace: data.workspace,
+            path: data.path
+        }
+    });
+};
+/**
+ * list kafka triggers
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.page which page to return (start at 1, default 1)
+ * @param data.perPage number of items to return for a given page (default 30, max 100)
+ * @param data.path filter by path
+ * @param data.isFlow
+ * @param data.pathStart
+ * @returns KafkaTrigger kafka trigger list
+ * @throws ApiError
+ */
+export const listKafkaTriggers = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/kafka_triggers/list',
+        path: {
+            workspace: data.workspace
+        },
+        query: {
+            page: data.page,
+            per_page: data.perPage,
+            path: data.path,
+            is_flow: data.isFlow,
+            path_start: data.pathStart
+        }
+    });
+};
+/**
+ * does kafka trigger exists
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.path
+ * @returns boolean kafka trigger exists
+ * @throws ApiError
+ */
+export const existsKafkaTrigger = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/kafka_triggers/exists/{path}',
+        path: {
+            workspace: data.workspace,
+            path: data.path
+        }
+    });
+};
+/**
+ * set enabled kafka trigger
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.path
+ * @param data.requestBody updated kafka trigger enable
+ * @returns string kafka trigger enabled set
+ * @throws ApiError
+ */
+export const setKafkaTriggerEnabled = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/kafka_triggers/setenabled/{path}',
+        path: {
+            workspace: data.workspace,
+            path: data.path
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
 /**
  * list instance groups
  * @returns InstanceGroup instance group list
@@ -6269,6 +6553,17 @@ export const getQueueMetrics = () => {
         url: '/workers/queue_metrics'
     });
 };
+/**
+ * get counts of jobs waiting for an executor per tag
+ * @returns number queue counts
+ * @throws ApiError
+ */
+export const getCountsOfJobsWaitingPerTag = () => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/workers/queue_counts'
+    });
+};
 /**
  * list worker groups
  * @returns unknown a list of worker group configs

package/esm/main.js

@@ -33,7 +33,7 @@ export { flow, app, script, workspace, resource, user, variable, hub, folder, sc
 //     console.error(JSON.stringify(event.error, null, 4));
 //   }
 // });
-export const VERSION = "1.423.1";
+export const VERSION = "1.426.0";
 const command = new Command()
     .name("wmill")
     .action(() => log.info(`Welcome to Windmill CLI ${VERSION}. Use -h for help.`))

package/esm/settings.js

@@ -47,7 +47,7 @@ export async function pushWorkspaceSettings(workspace, _path, settings, localSet
             error_handler: remoteSettings.error_handler,
             error_handler_extra_args: remoteSettings.error_handler_extra_args,
             error_handler_muted_on_cancel: remoteSettings.error_handler_muted_on_cancel,
-            openai_resource_path: remoteSettings.openai_resource_path,
+            ai_resource: remoteSettings.ai_resource,
             code_completion_enabled: remoteSettings.code_completion_enabled,
             large_file_storage: remoteSettings.large_file_storage,
             git_sync: remoteSettings.git_sync,
@@ -110,13 +110,13 @@ export async function pushWorkspaceSettings(workspace, _path, settings, localSet
             });
         }
     }
-    if (localSettings.openai_resource_path !== settings.openai_resource_path ||
+    if (localSettings.ai_resource !== settings.ai_resource ||
         localSettings.code_completion_enabled !== settings.code_completion_enabled) {
         log.debug(`Updating openai settings...`);
         await wmill.editCopilotConfig({
             workspace,
             requestBody: {
-                openai_resource_path: localSettings.openai_resource_path,
+                ai_resource: localSettings.ai_resource,
                 code_completion_enabled: localSettings.code_completion_enabled,
             },
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windmill-cli",
-  "version": "1.423.1",
+  "version": "1.426.0",
   "description": "CLI for Windmill",
   "repository": {
     "type": "git",

package/types/deps/jsr.io/@std/bytes/{1.0.3 → 1.0.4}/concat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.3/concat.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,UAAU,CAaxD"}
+{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.4/concat.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,UAAU,CAaxD"}

package/types/deps/jsr.io/@std/log/0.224.10/_config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_config.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/_config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,eAAO,MAAM,aAAa,SAAS,CAAC;AAEpC,eAAO,MAAM,cAAc,EAAE,SAW5B,CAAC"}

package/types/deps/jsr.io/@std/log/0.224.10/_file_handler_symbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_file_handler_symbols.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/_file_handler_symbols.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,UAAU,eAAiB,CAAC;AACzC,eAAO,MAAM,SAAS,eAAgB,CAAC;AACvC,eAAO,MAAM,aAAa,eAAoB,CAAC;AAC/C,eAAO,MAAM,cAAc,eAAqB,CAAC;AACjD,eAAO,MAAM,UAAU,eAAiB,CAAC;AACzC,eAAO,MAAM,iBAAiB,eAAwB,CAAC;AACvD,eAAO,MAAM,aAAa,eAAoB,CAAC"}

package/types/deps/jsr.io/@std/log/0.224.10/_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_state.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/_state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,eAAO,MAAM,KAAK;;;;CAIjB,CAAC"}

package/types/deps/jsr.io/@std/log/0.224.10/base_handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/base_handler.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,QAAQ,EACd,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,SAAS,EAAE,SAAS,KAAK,MAAM,CAAC;AAIjE,2CAA2C;AAC3C,MAAM,WAAW,kBAAkB;IACjC,2CAA2C;IAC3C,SAAS,CAAC,EAAE,iBAAiB,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,8BAAsB,WAAW;;IAG/B;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,SAAS,EAAE,iBAAiB,CAAC;IAE7B;;;;;OAKG;gBAED,SAAS,EAAE,SAAS,EACpB,OAAO,CAAC,EAAE,kBAAkB;IAQ9B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,KAAK,IAAI,QAAQ,CAEpB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,IAAI,KAAK,CAAC,KAAK,EAAE,QAAQ,EAGxB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,IAAI,SAAS,IAAI,SAAS,CAEzB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,SAAS,CAAC,SAAS,EAAE,SAAS,EAGjC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,MAAM,CAAC,SAAS,EAAE,SAAS;IAO3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM;IAIpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,KAAK;IAEL;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO;IAEP;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC;CAGjB"}

package/types/deps/jsr.io/@std/log/0.224.10/console_handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/console_handler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEzE,8CAA8C;AAC9C,MAAM,WAAW,qBAAsB,SAAQ,kBAAkB;IAC/D;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAuBD;;;;;;;;;;;GAWG;AACH,qBAAa,cAAe,SAAQ,WAAW;;IAG7C;;;;;OAKG;gBACS,SAAS,EAAE,SAAS,EAAE,OAAO,GAAE,qBAA0B;IAKrE;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACM,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM;IAU7C;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM;CAIhB"}

package/types/deps/jsr.io/@std/log/0.224.10/critical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"critical.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/critical.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;AAC7E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,GAAG,EAAE,CAAC,SAAS,eAAe,GAAG,KAAK,GAAG,CAAC,EAC1C,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,CAAC,CAAC"}

package/types/deps/jsr.io/@std/log/0.224.10/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/debug.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;AAC1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,GAAG,EAAE,CAAC,SAAS,eAAe,GAAG,KAAK,GAAG,CAAC,EAC1C,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,CAAC,CAAC"}

package/types/deps/jsr.io/@std/log/0.224.10/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/error.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;AAC1E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,GAAG,EAAE,CAAC,SAAS,eAAe,GAAG,KAAK,GAAG,CAAC,EAC1C,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,CAAC,CAAC"}

package/types/deps/jsr.io/@std/log/0.224.10/file_handler.d.ts

@@ -0,0 +1,251 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+import { type LevelName } from "./levels.js";
+import type { LogRecord } from "./logger.js";
+import { BaseHandler, type BaseHandlerOptions } from "./base_handler.js";
+import { bufSymbol, encoderSymbol, filenameSymbol, fileSymbol, modeSymbol, openOptionsSymbol, pointerSymbol } from "./_file_handler_symbols.js";
+/** Supported log modes for FileHandlerOptions {@linkcode FileHandlerOptions.mode}. */
+export type LogMode = "a" | "w" | "x";
+/** Options for {@linkcode FileHandler}. */
+export interface FileHandlerOptions extends BaseHandlerOptions {
+    /**
+     * The filename to output to.
+     */
+    filename: string;
+    /**
+     * Log mode for the handler. Behavior of the log modes is as follows:
+     *
+     * - `'a'` - Default mode. Appends new log messages to the end of an existing log
+     *   file, or create a new log file if none exists.
+     * - `'w'` - Upon creation of the handler, any existing log file will be removed
+     *   and a new one created.
+     * - `'x'` - This will create a new log file and throw an error if one already
+     *   exists.
+     *
+     * @default {"a"}
+     */
+    mode?: LogMode;
+    /**
+     * Buffer size for writing log messages to file, in bytes.
+     *
+     * @default {4096}
+     */
+    bufferSize?: number;
+}
+/**
+ * A file-based log handler that writes log messages to a specified file with buffering and optional modes.
+ * The logs are buffered for optimized performance, writing to the file only
+ * when the buffer is full, on manual .flush() call, during logging of a critical message or when process ends.
+ * It is important to note that the file can grow indefinitely.
+ *
+ * This handler requires `--allow-write` permission on the log file.
+ *
+ * @example Usage
+ * ```ts no-assert ignore
+ * import { FileHandler } from "@std/log/file-handler";
+ *
+ * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+ * handler.setup();
+ * handler.log('Hello, world!'); // Buffers the message, or writes it to the file depending on buffer state
+ * handler.flush(); // Manually flushes the buffer
+ * handler.destroy(); // Closes the file and removes listeners
+ * ```
+ */
+export declare class FileHandler extends BaseHandler {
+    #private;
+    /** Opened file to append logs to.
+     * @example Usage
+     * ```ts no-assert ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+     * handler.setup();
+     * handler.log('Hello, world!'); // Buffers the message, or writes it to the file depending on buffer state
+     * handler.flush(); // Manually flushes the buffer
+     * handler.destroy(); // Closes the file and removes listeners
+     * ```
+     * **/
+    [fileSymbol]: dntShim.Deno.FsFile | undefined;
+    /** Buffer used to write to file.
+     * @example Usage
+     * ```ts no-assert ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+     * handler.setup();
+     * handler.log('Hello, world!'); // Buffers the message, or writes it to the file depending on buffer state
+     * handler.flush(); // Manually flushes the buffer
+     * handler.destroy(); // Closes the file and removes listeners
+     * ```
+     * **/
+    [bufSymbol]: Uint8Array;
+    /** Current position for pointer.
+     * @example Usage
+     * ```ts no-assert ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+     * handler.setup();
+     * handler.log('Hello, world!'); // Buffers the message, or writes it to the file depending on buffer state
+     * handler.flush(); // Manually flushes the buffer
+     * handler.destroy(); // Closes the file and removes listeners
+     * ```
+     * **/
+    [pointerSymbol]: number;
+    /** Filename associated with the file being logged.
+     * @example Usage
+     * ```ts no-assert ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+     * handler.setup();
+     * handler.log('Hello, world!'); // Buffers the message, or writes it to the file depending on buffer state
+     * handler.flush(); // Manually flushes the buffer
+     * handler.destroy(); // Closes the file and removes listeners
+     * ```
+     * **/
+    [filenameSymbol]: string;
+    /** Current log mode.
+     * @example Usage
+     * ```ts no-assert ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+     * handler.setup();
+     * handler.log('Hello, world!'); // Buffers the message, or writes it to the file depending on buffer state
+     * handler.flush(); // Manually flushes the buffer
+     * handler.destroy(); // Closes the file and removes listeners
+     * ```
+     * **/
+    [modeSymbol]: LogMode;
+    /** File open options.
+     * @example Usage
+     * ```ts no-assert ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+     * handler.setup();
+     * handler.log('Hello, world!'); // Buffers the message, or writes it to the file depending on buffer state
+     * handler.flush(); // Manually flushes the buffer
+     * handler.destroy(); // Closes the file and removes listeners
+     * ```
+     * **/
+    [openOptionsSymbol]: dntShim.Deno.OpenOptions;
+    /** Text encoder.
+     * @example Usage
+     * ```ts no-assert ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+     * handler.setup();
+     * handler.log('Hello, world!'); // Buffers the message, or writes it to the file depending on buffer state
+     * handler.flush(); // Manually flushes the buffer
+     * handler.destroy(); // Closes the file and removes listeners
+     * ```
+     * **/
+    [encoderSymbol]: TextEncoder;
+    /**
+     * Constructs a new FileHandler instance.
+     *
+     * @param levelName The level name to log messages at.
+     * @param options Options for the handler.
+     */
+    constructor(levelName: LevelName, options: FileHandlerOptions);
+    /**
+     * Sets up the file handler by opening the specified file and initializing resources.
+     *
+     * @example Usage
+     * ```ts no-assert ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+     * handler.setup(); // Opens the file and prepares the handler for logging.
+     * handler.destroy();
+     * ```
+     */
+    setup(): void;
+    /**
+     * Handles a log record and flushes the buffer if the log level is higher than error.
+     *
+     * @param logRecord Log record to handle.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     * import { LogLevels } from "./levels.ts";
+     * import { LogRecord } from "./logger.ts";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+     * handler.setup();
+     *
+     * // Flushes the buffer immediately and logs "CRITICAL This log is very critical indeed." into the file.
+     * handler.handle(
+     *   new LogRecord({
+     *     msg: "This log is very critical indeed.",
+     *     args: [],
+     *     level: LogLevels.CRITICAL,
+     *     loggerName: "INFO",
+     *   }),
+     * );
+     * handler.destroy();
+     *
+     * assertInstanceOf(handler, FileHandler);
+     * ```
+     */
+    handle(logRecord: LogRecord): void;
+    /**
+     * Logs a message by adding it to the buffer, with flushing as needed.
+     *
+     * @param msg The message to log.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+     * handler.setup();
+     * handler.log('Hello, world!');
+     * handler.flush();
+     * handler.destroy();
+     *
+     * assertInstanceOf(handler, FileHandler);
+     * ```
+     */
+    log(msg: string): void;
+    /**
+     * Immediately writes the contents of the buffer to the previously opened file.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+     * handler.setup();
+     * handler.log('Hello, world!');
+     * handler.flush(); // Writes buffered log messages to the file immediately.
+     * handler.destroy();
+     *
+     * assertInstanceOf(handler, FileHandler);
+     * ```
+     */
+    flush(): void;
+    /**
+     * Destroys the handler, performing any cleanup that is required and closes the file handler.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { FileHandler } from "@std/log/file-handler";
+     * import { assertInstanceOf } from "@std/assert/instance-of";
+     *
+     * const handler = new FileHandler("INFO", { filename: "./logs.txt" });
+     * handler.setup();
+     * handler.destroy();
+     *
+     * assertInstanceOf(handler, FileHandler);
+     * ```
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=file_handler.d.ts.map

package/types/deps/jsr.io/@std/log/0.224.10/file_handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/file_handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAC;AAExD,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEzE,OAAO,EACL,SAAS,EACT,aAAa,EACb,cAAc,EACd,UAAU,EACV,UAAU,EACV,iBAAiB,EACjB,aAAa,EACd,MAAM,4BAA4B,CAAC;AAEpC,sFAAsF;AACtF,MAAM,MAAM,OAAO,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAEtC,2CAA2C;AAC3C,MAAM,WAAW,kBAAmB,SAAQ,kBAAkB;IAC5D;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,WAAY,SAAQ,WAAW;;IAC1C;;;;;;;;;;;UAWM;IACN,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;IAC9C;;;;;;;;;;;UAWM;IACN,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC;IACxB;;;;;;;;;;;UAWM;IACN,CAAC,aAAa,CAAC,SAAK;IACpB;;;;;;;;;;;UAWM;IACN,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;UAWM;IACN,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;;;;;;;UAWM;IACN,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC;IAC9C;;;;;;;;;;;UAWM;IACN,CAAC,aAAa,CAAC,EAAE,WAAW,CAAqB;IAKjD;;;;;OAKG;gBACS,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,kBAAkB;IAe7D;;;;;;;;;;;OAWG;IACM,KAAK;IAUd;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACM,MAAM,CAAC,SAAS,EAAE,SAAS;IASpC;;;;;;;;;;;;;;;;;;OAkBG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM;IAaf;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK;IAgBL;;;;;;;;;;;;;;OAcG;IACM,OAAO;CAMjB"}

package/types/deps/jsr.io/@std/log/0.224.10/formatters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.10/formatters.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAO1D;AAUD,kCAAkC;AAClC,eAAO,MAAM,UAAU;;CAA6B,CAAC"}