structured-outputs 0.1.0-beta.7 → 0.1.0-beta.9

package/types/deps/jsr.io/@std/dotenv/0.225.2/mod.d.ts

@@ -0,0 +1,164 @@
+export * from "./stringify.js";
+export * from "./parse.js";
+/** Options for {@linkcode load} and {@linkcode loadSync}. */
+export interface LoadOptions {
+    /**
+     * Optional path to `.env` file. To prevent the default value from being
+     * used, set to `null`.
+     *
+     * @default {"./.env"}
+     */
+    envPath?: string | null;
+    /**
+     * Set to `true` to export all `.env` variables to the current processes
+     * environment. Variables are then accessible via `Deno.env.get(<key>)`.
+     *
+     * @default {false}
+     */
+    export?: boolean;
+}
+/**
+ * Works identically to {@linkcode load}, but synchronously.
+ *
+ * @example Usage
+ * ```ts no-eval
+ * import { loadSync } from "@std/dotenv";
+ *
+ * const conf = loadSync();
+ * ```
+ *
+ * @param options Options for loading the environment variables.
+ * @returns The parsed environment variables.
+ */
+export declare function loadSync(options?: LoadOptions): Record<string, string>;
+/**
+ * Load environment variables from a `.env` file.  Loaded variables are accessible
+ * in a configuration object returned by the `load()` function, as well as optionally
+ * exporting them to the process environment using the `export` option.
+ *
+ * Inspired by the node modules {@linkcode https://github.com/motdotla/dotenv | dotenv}
+ * and {@linkcode https://github.com/motdotla/dotenv-expand | dotenv-expand}.
+ *
+ * Note: The key needs to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.
+ *
+ * ## Basic usage
+ * ```sh
+ * # .env
+ * GREETING=hello world
+ * ```
+ *
+ * Then import the environment variables using the `load` function.
+ *
+ * @example Basic usage
+ * ```ts no-eval
+ * // app.ts
+ * import { load } from "@std/dotenv";
+ *
+ * console.log(await load({ export: true })); // { GREETING: "hello world" }
+ * console.log(Deno.env.get("GREETING")); // hello world
+ * ```
+ *
+ * Run this with `deno run --allow-read --allow-env app.ts`.
+ *
+ * .env files support blank lines, comments, multi-line values and more.
+ * See Parsing Rules below for more detail.
+ *
+ * ## Auto loading
+ * Import the `load.ts` module to auto-import from the `.env` file and into
+ * the process environment.
+ *
+ * @example Auto-loading
+ * ```ts no-eval
+ * // app.ts
+ * import "@std/dotenv/load";
+ *
+ * console.log(Deno.env.get("GREETING")); // hello world
+ * ```
+ *
+ * Run this with `deno run --allow-read --allow-env app.ts`.
+ *
+ * ## Files
+ * Dotenv supports a number of different files, all of which are optional.
+ * File names and paths are configurable.
+ *
+ * |File|Purpose|
+ * |----|-------|
+ * |.env|primary file for storing key-value environment entries
+ *
+ * ## Configuration
+ *
+ * Loading environment files comes with a number of options passed into
+ * the `load()` function, all of which are optional.
+ *
+ * |Option|Default|Description
+ * |------|-------|-----------
+ * |envPath|./.env|Path and filename of the `.env` file.  Use null to prevent the .env file from being loaded.
+ * |export|false|When true, this will export all environment variables in the `.env` file to the process environment (e.g. for use by `Deno.env.get()`) but only if they are not already set.  If a variable is already in the process, the `.env` value is ignored.
+ *
+ * ### Example configuration
+ *
+ * @example Using with options
+ * ```ts no-eval
+ * import { load } from "@std/dotenv";
+ *
+ * const conf = await load({
+ *   envPath: "./.env_prod", // Uses .env_prod instead of .env
+ *   export: true, // Exports all variables to the environment
+ * });
+ * ```
+ *
+ * ## Permissions
+ *
+ * At a minimum, loading the `.env` related files requires the `--allow-read` permission.  Additionally, if
+ * you access the process environment, either through exporting your configuration or expanding variables
+ * in your `.env` file, you will need the `--allow-env` permission.  E.g.
+ *
+ * ```sh
+ * deno run --allow-read=.env --allow-env=ENV1,ENV2 app.ts
+ * ```
+ *
+ * ## Parsing Rules
+ *
+ * The parsing engine currently supports the following rules:
+ *
+ * - Variables that already exist in the environment are not overridden with
+ *   `export: true`
+ * - `BASIC=basic` becomes `{ BASIC: "basic" }`
+ * - empty lines are skipped
+ * - lines beginning with `#` are treated as comments
+ * - empty values become empty strings (`EMPTY=` becomes `{ EMPTY: "" }`)
+ * - single and double quoted values are escaped (`SINGLE_QUOTE='quoted'` becomes
+ *   `{ SINGLE_QUOTE: "quoted" }`)
+ * - new lines are expanded in double quoted values (`MULTILINE="new\nline"`
+ *   becomes
+ *
+ * ```
+ * { MULTILINE: "new\nline" }
+ * ```
+ *
+ * - inner quotes are maintained (think JSON) (`JSON={"foo": "bar"}` becomes
+ *   `{ JSON: "{\"foo\": \"bar\"}" }`)
+ * - whitespace is removed from both ends of unquoted values (see more on
+ *   {@linkcode https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim | trim})
+ *   (`FOO= some value` becomes `{ FOO: "some value" }`)
+ * - whitespace is preserved on both ends of quoted values (`FOO=" some value "`
+ *   becomes `{ FOO: " some value " }`)
+ * - dollar sign with an environment key in or without curly braces in unquoted
+ *   values will expand the environment key (`KEY=$KEY` or `KEY=${KEY}` becomes
+ *   `{ KEY: "<KEY_VALUE_FROM_ENV>" }`)
+ * - escaped dollar sign with an environment key in unquoted values will escape the
+ *   environment key rather than expand (`KEY=\$KEY` becomes `{ KEY: "\\$KEY" }`)
+ * - colon and a minus sign with a default value(which can also be another expand
+ *   value) in expanding construction in unquoted values will first attempt to
+ *   expand the environment key. If it’s not found, then it will return the default
+ *   value (`KEY=${KEY:-default}` If KEY exists it becomes
+ *   `{ KEY: "<KEY_VALUE_FROM_ENV>" }` If not, then it becomes
+ *   `{ KEY: "default" }`. Also there is possible to do this case
+ *   `KEY=${NO_SUCH_KEY:-${EXISTING_KEY:-default}}` which becomes
+ *   `{ KEY: "<EXISTING_KEY_VALUE_FROM_ENV>" }`)
+ *
+ * @param options The options
+ * @returns The parsed environment variables
+ */
+export declare function load(options?: LoadOptions): Promise<Record<string, string>>;
+//# sourceMappingURL=mod.d.ts.map

package/types/deps/jsr.io/@std/dotenv/0.225.2/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/dotenv/0.225.2/mod.ts"],"names":[],"mappings":"AA4BA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAE3B,6DAA6D;AAC7D,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAExB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CACtB,OAAO,GAAE,WAAgB,GACxB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAexB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgIG;AACH,wBAAsB,IAAI,CACxB,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAejC"}

package/types/deps/jsr.io/@std/dotenv/0.225.2/parse.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Parse `.env` file output in an object.
+ *
+ * Note: The key needs to match the pattern /^[a-zA-Z_][a-zA-Z0-9_]*$/.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/dotenv/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const env = parse("GREETING=hello world");
+ * assertEquals(env, { GREETING: "hello world" });
+ * ```
+ *
+ * @param text The text to parse.
+ * @returns The parsed object.
+ */
+export declare function parse(text: string): Record<string, string>;
+//# sourceMappingURL=parse.d.ts.map

package/types/deps/jsr.io/@std/dotenv/0.225.2/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/dotenv/0.225.2/parse.ts"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAmC1D"}

package/types/deps/jsr.io/@std/dotenv/0.225.2/stringify.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Stringify an object into a valid `.env` file format.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/dotenv/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const object = { GREETING: "hello world" };
+ * assertEquals(stringify(object), "GREETING='hello world'");
+ * ```
+ *
+ * @param object object to be stringified
+ * @returns string of object
+ */
+export declare function stringify(object: Record<string, string>): string;
+//# sourceMappingURL=stringify.d.ts.map

package/types/deps/jsr.io/@std/dotenv/0.225.2/stringify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringify.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/dotenv/0.225.2/stringify.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CA4BhE"}

package/types/deps/jsr.io/@std/fs/1.0.5/_create_walk_entry.d.ts

@@ -0,0 +1,14 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+/**
+ * Walk entry for {@linkcode walk}, {@linkcode walkSync},
+ * {@linkcode expandGlob} and {@linkcode expandGlobSync}.
+ */
+export interface WalkEntry extends dntShim.Deno.DirEntry {
+    /** Full path of the entry. */
+    path: string;
+}
+/** Create {@linkcode WalkEntry} for the `path` synchronously. */
+export declare function createWalkEntrySync(path: string | URL): WalkEntry;
+/** Create {@linkcode WalkEntry} for the `path` asynchronously. */
+export declare function createWalkEntry(path: string | URL): Promise<WalkEntry>;
+//# sourceMappingURL=_create_walk_entry.d.ts.map

package/types/deps/jsr.io/@std/fs/1.0.5/_create_walk_entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_create_walk_entry.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.5/_create_walk_entry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAC;AAOxD;;;GAGG;AACH,MAAM,WAAW,SAAU,SAAQ,OAAO,CAAC,IAAI,CAAC,QAAQ;IACtD,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,iEAAiE;AACjE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAYjE;AAED,kEAAkE;AAClE,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,CAAC,SAAS,CAAC,CAY5E"}

package/types/deps/jsr.io/@std/fs/1.0.5/_get_file_info_type.d.ts

@@ -0,0 +1,13 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+export type PathType = "file" | "dir" | "symlink";
+/**
+ * Get a human readable file type string.
+ *
+ * @param file File information, as returned by {@linkcode Deno.stat} or
+ * {@linkcode Deno.lstat}.
+ *
+ * @returns The file type as a string, or `undefined` if the file type is
+ * unknown.
+ */
+export declare function getFileInfoType(fileInfo: dntShim.Deno.FileInfo): PathType | undefined;
+//# sourceMappingURL=_get_file_info_type.d.ts.map

package/types/deps/jsr.io/@std/fs/1.0.5/_get_file_info_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_get_file_info_type.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.5/_get_file_info_type.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAC;AAGxD,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;AAElD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAQrF"}

package/types/deps/jsr.io/@std/fs/1.0.5/_is_same_path.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Checks if two paths are the same.
+ *
+ * @param src Source file path as a string or URL.
+ * @param dest Destination file path as a string or URL.
+ *
+ * @returns `true` if the paths are the same, `false` otherwise.
+ */
+export declare function isSamePath(src: string | URL, dest: string | URL): boolean;
+//# sourceMappingURL=_is_same_path.d.ts.map

package/types/deps/jsr.io/@std/fs/1.0.5/_is_same_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_is_same_path.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.5/_is_same_path.ts"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,IAAI,EAAE,MAAM,GAAG,GAAG,GACjB,OAAO,CAKT"}

package/types/deps/jsr.io/@std/fs/1.0.5/_is_subdir.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Checks whether `src` is a sub-directory of `dest`.
+ *
+ * @param src Source file path as a string or URL.
+ * @param dest Destination file path as a string or URL.
+ * @param sep Path separator. Defaults to `\\` for Windows and `/` for other
+ * platforms.
+ *
+ * @returns `true` if `src` is a sub-directory of `dest`, `false` otherwise.
+ */
+export declare function isSubdir(src: string | URL, dest: string | URL, sep?: "\\" | "/"): boolean;
+//# sourceMappingURL=_is_subdir.d.ts.map

package/types/deps/jsr.io/@std/fs/1.0.5/_is_subdir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_is_subdir.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.5/_is_subdir.ts"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,GAAG,aAAY,GACd,OAAO,CAYT"}

package/types/deps/jsr.io/@std/fs/1.0.5/_to_path_string.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Convert a URL or string to a path.
+ *
+ * @param pathUrl A URL or string to be converted.
+ *
+ * @returns The path as a string.
+ */
+export declare function toPathString(pathUrl: string | URL): string;
+//# sourceMappingURL=_to_path_string.d.ts.map

package/types/deps/jsr.io/@std/fs/1.0.5/_to_path_string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_to_path_string.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.5/_to_path_string.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,GAAG,GAAG,GACpB,MAAM,CAER"}

package/types/deps/jsr.io/@std/fs/1.0.5/copy.d.ts

@@ -0,0 +1,117 @@
+/** Options for {@linkcode copy} and {@linkcode copySync}. */
+export interface CopyOptions {
+    /**
+     * Whether to overwrite existing file or directory.
+     *
+     * @default {false}
+     */
+    overwrite?: boolean;
+    /**
+     * When `true`, will set last modification and access times to the ones of
+     * the original source files. When `false`, timestamp behavior is
+     * OS-dependent.
+     *
+     * > [!NOTE]
+     * > This option is currently unsupported for symbolic links.
+     *
+     * @default {false}
+     */
+    preserveTimestamps?: boolean;
+}
+/**
+ * Asynchronously copy a file or directory (along with its contents), like
+ * {@linkcode https://www.ibm.com/docs/en/aix/7.3?topic=c-cp-command#cp__cp_flagr | cp -r}.
+ *
+ * Both `src` and `dest` must both be a file or directory.
+ *
+ * Requires `--allow-read` and `--allow-write` permissions.
+ *
+ * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
+ * for more information on Deno's permissions system.
+ *
+ * @param src The source file/directory path as a string or URL.
+ * @param dest The destination file/directory path as a string or URL.
+ * @param options Options for copying.
+ *
+ * @returns A promise that resolves once the copy operation completes.
+ *
+ * @example Basic usage
+ * ```ts ignore
+ * import { copy } from "@std/fs/copy";
+ *
+ * await copy("./foo", "./bar");
+ * ```
+ *
+ * This will copy the file or directory at `./foo` to `./bar` without
+ * overwriting.
+ *
+ * @example Overwriting files/directories
+ * ```ts ignore
+ * import { copy } from "@std/fs/copy";
+ *
+ * await copy("./foo", "./bar", { overwrite: true });
+ * ```
+ *
+ * This will copy the file or directory at `./foo` to `./bar` and overwrite
+ * any existing files or directories.
+ *
+ * @example Preserving timestamps
+ * ```ts ignore
+ * import { copy } from "@std/fs/copy";
+ *
+ * await copy("./foo", "./bar", { preserveTimestamps: true });
+ * ```
+ *
+ * This will copy the file or directory at `./foo` to `./bar` and set the
+ * last modification and access times to the ones of the original source files.
+ */
+export declare function copy(src: string | URL, dest: string | URL, options?: CopyOptions): Promise<void>;
+/**
+ * Synchronously copy a file or directory (along with its contents), like
+ * {@linkcode https://www.ibm.com/docs/en/aix/7.3?topic=c-cp-command#cp__cp_flagr | cp -r}.
+ *
+ * Both `src` and `dest` must both be a file or directory.
+ *
+ * Requires `--allow-read` and `--allow-write` permissions.
+ *
+ * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
+ * for more information on Deno's permissions system.
+ *
+ * @param src The source file/directory path as a string or URL.
+ * @param dest The destination file/directory path as a string or URL.
+ * @param options Options for copying.
+ *
+ * @returns A void value that returns once the copy operation completes.
+ *
+ * @example Basic usage
+ * ```ts ignore
+ * import { copySync } from "@std/fs/copy";
+ *
+ * copySync("./foo", "./bar");
+ * ```
+ *
+ * This will copy the file or directory at `./foo` to `./bar` without
+ * overwriting.
+ *
+ * @example Overwriting files/directories
+ * ```ts ignore
+ * import { copySync } from "@std/fs/copy";
+ *
+ * copySync("./foo", "./bar", { overwrite: true });
+ * ```
+ *
+ * This will copy the file or directory at `./foo` to `./bar` and overwrite
+ * any existing files or directories.
+ *
+ * @example Preserving timestamps
+ * ```ts ignore
+ * import { copySync } from "@std/fs/copy";
+ *
+ * copySync("./foo", "./bar", { preserveTimestamps: true });
+ * ```
+ *
+ * This will copy the file or directory at `./foo` to `./bar` and set the
+ * last modification and access times to the ones of the original source files.
+ */
+export declare function copySync(src: string | URL, dest: string | URL, options?: CopyOptions): void;
+//# sourceMappingURL=copy.d.ts.map

package/types/deps/jsr.io/@std/fs/1.0.5/copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.5/copy.ts"],"names":[],"mappings":"AAeA,6DAA6D;AAC7D,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;;;;;OASG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAoOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAsB,IAAI,CACxB,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,GAAE,WAAgB,iBAwB1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,QAAQ,CACtB,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,GAAE,WAAgB,QAwB1B"}

package/types/deps/jsr.io/@std/fs/1.0.5/empty_dir.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Asynchronously ensures that a directory is empty.
+ *
+ * If the directory does not exist, it is created. The directory itself is not
+ * deleted.
+ *
+ * Requires `--allow-read` and `--allow-write` permissions.
+ *
+ * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
+ * for more information on Deno's permissions system.
+ *
+ * @param dir The path of the directory to empty, as a string or URL.
+ *
+ * @returns A void promise that resolves once the directory is empty.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { emptyDir } from "@std/fs/empty-dir";
+ *
+ * await emptyDir("./foo");
+ * ```
+ */
+export declare function emptyDir(dir: string | URL): Promise<void>;
+/**
+ * Synchronously ensures that a directory is empty deletes the directory
+ * contents it is not empty.
+ *
+ * If the directory does not exist, it is created. The directory itself is not
+ * deleted.
+ *
+ * Requires `--allow-read` and `--allow-write` permissions.
+ *
+ * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
+ * for more information on Deno's permissions system.
+ *
+ * @param dir The path of the directory to empty, as a string or URL.
+ *
+ * @returns A void value that returns once the directory is empty.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { emptyDirSync } from "@std/fs/empty-dir";
+ *
+ * emptyDirSync("./foo");
+ * ```
+ */
+export declare function emptyDirSync(dir: string | URL): void;
+//# sourceMappingURL=empty_dir.d.ts.map

package/types/deps/jsr.io/@std/fs/1.0.5/empty_dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty_dir.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.5/empty_dir.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,iBAkB/C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,QAmB7C"}

package/types/deps/jsr.io/@std/fs/1.0.5/ensure_dir.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Asynchronously ensures that the directory exists, like
+ * {@linkcode https://www.ibm.com/docs/en/aix/7.3?topic=m-mkdir-command#mkdir__row-d3e133766 | mkdir -p}.
+ *
+ * If the directory already exists, this function does nothing. If the directory
+ * does not exist, it is created.
+ *
+ * Requires `--allow-read` and `--allow-write` permissions.
+ *
+ * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
+ * for more information on Deno's permissions system.
+ *
+ * @param dir The path of the directory to ensure, as a string or URL.
+ *
+ * @returns A promise that resolves once the directory exists.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { ensureDir } from "@std/fs/ensure-dir";
+ *
+ * await ensureDir("./bar");
+ * ```
+ */
+export declare function ensureDir(dir: string | URL): Promise<void>;
+/**
+ * Synchronously ensures that the directory exists, like
+ * {@linkcode https://www.ibm.com/docs/en/aix/7.3?topic=m-mkdir-command#mkdir__row-d3e133766 | mkdir -p}.
+ *
+ * If the directory already exists, this function does nothing. If the directory
+ * does not exist, it is created.
+ *
+ * Requires `--allow-read` and `--allow-write` permissions.
+ *
+ * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
+ * for more information on Deno's permissions system.
+ *
+ * @param dir The path of the directory to ensure, as a string or URL.
+ *
+ * @returns A void value that returns once the directory exists.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { ensureDirSync } from "@std/fs/ensure-dir";
+ *
+ * ensureDirSync("./bar");
+ * ```
+ */
+export declare function ensureDirSync(dir: string | URL): void;
+//# sourceMappingURL=ensure_dir.d.ts.map

package/types/deps/jsr.io/@std/fs/1.0.5/ensure_dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure_dir.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.5/ensure_dir.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,iBAuBhD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,QAuB9C"}

package/types/deps/jsr.io/@std/fs/1.0.5/ensure_file.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Asynchronously ensures that the file exists.
+ *
+ * If the file already exists, this function does nothing. If the parent
+ * directories for the file do not exist, they are created.
+ *
+ * Requires `--allow-read` and `--allow-write` permissions.
+ *
+ * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
+ * for more information on Deno's permissions system.
+ *
+ * @param filePath The path of the file to ensure, as a string or URL.
+ *
+ * @returns A void promise that resolves once the file exists.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { ensureFile } from "@std/fs/ensure-file";
+ *
+ * await ensureFile("./folder/targetFile.dat");
+ * ```
+ */
+export declare function ensureFile(filePath: string | URL): Promise<void>;
+/**
+ * Synchronously ensures that the file exists.
+ *
+ * If the file already exists, this function does nothing. If the parent
+ * directories for the file do not exist, they are created.
+ *
+ * Requires `--allow-read` and `--allow-write` permissions.
+ *
+ * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
+ * for more information on Deno's permissions system.
+ *
+ * @param filePath The path of the file to ensure, as a string or URL.
+ *
+ * @returns A void value that returns once the file exists.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { ensureFileSync } from "@std/fs/ensure-file";
+ *
+ * ensureFileSync("./folder/targetFile.dat");
+ * ```
+ */
+export declare function ensureFileSync(filePath: string | URL): void;
+//# sourceMappingURL=ensure_file.d.ts.map

package/types/deps/jsr.io/@std/fs/1.0.5/ensure_file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure_file.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.5/ensure_file.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBtE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI,CAsB3D"}

package/types/deps/jsr.io/@std/fs/1.0.5/ensure_link.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Asynchronously ensures that the hard link exists.
+ *
+ * If the parent directories for the hard link do not exist, they are created.
+ *
+ * Requires `--allow-read` and `--allow-write` permissions.
+ *
+ * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
+ * for more information on Deno's permissions system.
+ *
+ * @param src The source file path as a string or URL. Directory hard links are
+ * not allowed.
+ * @param dest The destination link path as a string or URL.
+ *
+ * @returns A void promise that resolves once the hard link exists.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { ensureLink } from "@std/fs/ensure-link";
+ *
+ * await ensureLink("./folder/targetFile.dat", "./folder/targetFile.link.dat");
+ * ```
+ */
+export declare function ensureLink(src: string | URL, dest: string | URL): Promise<void>;
+/**
+ * Synchronously ensures that the hard link exists.
+ *
+ * If the parent directories for the hard link do not exist, they are created.
+ *
+ * Requires `--allow-read` and `--allow-write` permissions.
+ *
+ * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
+ * for more information on Deno's permissions system.
+ *
+ * @param src The source file path as a string or URL. Directory hard links are
+ * not allowed.
+ * @param dest The destination link path as a string or URL.
+ *
+ * @returns A void value that returns once the hard link exists.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { ensureLinkSync } from "@std/fs/ensure-link";
+ *
+ * ensureLinkSync("./folder/targetFile.dat", "./folder/targetFile.link.dat");
+ * ```
+ */
+export declare function ensureLinkSync(src: string | URL, dest: string | URL): void;
+//# sourceMappingURL=ensure_link.d.ts.map

package/types/deps/jsr.io/@std/fs/1.0.5/ensure_link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure_link.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.5/ensure_link.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG,iBAKrE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG,QAKnE"}