@tachybase/plugin-mock-collections 0.23.8

package/dist/node_modules/@faker-js/faker/dist/types/modules/lorem/index.d.ts

@@ -0,0 +1,288 @@
+import { ModuleBase } from '../../internal/module-base';
+/**
+ * Module to generate random texts and words.
+ *
+ * ### Overview
+ *
+ * Generate dummy content using traditional faux-Latin [lorem ipsum](https://en.wikipedia.org/wiki/Lorem_ipsum) (in other locales to `en`, alternative words may be used).
+ *
+ * In order of increasing size you can generate a single [`word()`](https://fakerjs.dev/api/lorem.html#word), multiple [`words()`](https://fakerjs.dev/api/lorem.html#words), a [`sentence()`](https://fakerjs.dev/api/lorem.html#sentence), multiple [`sentences()`](https://fakerjs.dev/api/lorem.html#sentences), [`lines()`](https://fakerjs.dev/api/lorem.html#lines) separated by newlines, one [`paragraph()`](https://fakerjs.dev/api/lorem.html#paragraph), or multiple [`paragraphs()`](https://fakerjs.dev/api/lorem.html#paragraphs).
+ *
+ * The generic [`text()`](https://fakerjs.dev/api/lorem.html#text) method can be used to generate some text between one sentence and multiple paragraphs, while [`slug()`](https://fakerjs.dev/api/lorem.html#slug) generates an URL-friendly hyphenated string.
+ */
+export declare class LoremModule extends ModuleBase {
+    /**
+     * Generates a word of a specified length.
+     *
+     * @param options The expected length of the word or the options to use.
+     * @param options.length The expected length of the word.
+     * @param options.strategy The strategy to apply when no words with a matching length are found.
+     *
+     * Available error handling strategies:
+     *
+     * - `fail`: Throws an error if no words with the given length are found.
+     * - `shortest`: Returns any of the shortest words.
+     * - `closest`: Returns any of the words closest to the given length.
+     * - `longest`: Returns any of the longest words.
+     * - `any-length`: Returns a word with any length.
+     *
+     * Defaults to `'any-length'`.
+     *
+     * @example
+     * faker.lorem.word() // 'temporibus'
+     * faker.lorem.word(5) // 'velit'
+     * faker.lorem.word({ strategy: 'shortest' }) // 'a'
+     * faker.lorem.word({ length: { min: 5, max: 7 }, strategy: 'fail' }) // 'quaerat'
+     *
+     * @since 3.1.0
+     */
+    word(options?: number | {
+        /**
+         * The expected length of the word.
+         *
+         * @default 1
+         */
+        length?: number | {
+            /**
+             * The minimum length of the word.
+             */
+            min: number;
+            /**
+             * The maximum length of the word.
+             */
+            max: number;
+        };
+        /**
+         * The strategy to apply when no words with a matching length are found.
+         *
+         * Available error handling strategies:
+         *
+         * - `fail`: Throws an error if no words with the given length are found.
+         * - `shortest`: Returns any of the shortest words.
+         * - `closest`: Returns any of the words closest to the given length.
+         * - `longest`: Returns any of the longest words.
+         * - `any-length`: Returns a word with any length.
+         *
+         * @default 'any-length'
+         */
+        strategy?: 'fail' | 'closest' | 'shortest' | 'longest' | 'any-length';
+    }): string;
+    /**
+     * Generates a space separated list of words.
+     *
+     * @param wordCount The number of words to generate. Defaults to `3`.
+     * @param wordCount.min The minimum number of words to generate.
+     * @param wordCount.max The maximum number of words to generate.
+     *
+     * @example
+     * faker.lorem.words() // 'qui praesentium pariatur'
+     * faker.lorem.words(10) // 'debitis consectetur voluptatem non doloremque ipsum autem totam eum ratione'
+     * faker.lorem.words({ min: 1, max: 3 }) // 'tenetur error cum'
+     *
+     * @since 2.0.1
+     */
+    words(wordCount?: number | {
+        /**
+         * The minimum number of words to generate.
+         */
+        min: number;
+        /**
+         * The maximum number of words to generate.
+         */
+        max: number;
+    }): string;
+    /**
+     * Generates a space separated list of words beginning with a capital letter and ending with a period.
+     *
+     * @param wordCount The number of words, that should be in the sentence. Defaults to a random number between `3` and `10`.
+     * @param wordCount.min The minimum number of words to generate. Defaults to `3`.
+     * @param wordCount.max The maximum number of words to generate. Defaults to `10`.
+     *
+     * @example
+     * faker.lorem.sentence() // 'Voluptatum cupiditate suscipit autem eveniet aut dolorem aut officiis distinctio.'
+     * faker.lorem.sentence(5) // 'Laborum voluptatem officiis est et.'
+     * faker.lorem.sentence({ min: 3, max: 5 }) // 'Fugiat repellendus nisi.'
+     *
+     * @since 2.0.1
+     */
+    sentence(wordCount?: number | {
+        /**
+         * The minimum number of words to generate.
+         */
+        min: number;
+        /**
+         * The maximum number of words to generate.
+         */
+        max: number;
+    }): string;
+    /**
+     * Generates a slugified text consisting of the given number of hyphen separated words.
+     *
+     * @param wordCount The number of words to generate. Defaults to `3`.
+     * @param wordCount.min The minimum number of words to generate.
+     * @param wordCount.max The maximum number of words to generate.
+     *
+     * @example
+     * faker.lorem.slug() // 'dolores-illo-est'
+     * faker.lorem.slug(5) // 'delectus-totam-iusto-itaque-placeat'
+     * faker.lorem.slug({ min: 1, max: 3 }) // 'illo-ratione'
+     *
+     * @since 4.0.0
+     */
+    slug(wordCount?: number | {
+        /**
+         * The minimum number of words to generate.
+         */
+        min: number;
+        /**
+         * The maximum number of words to generate.
+         */
+        max: number;
+    }): string;
+    /**
+     * Generates the given number of sentences.
+     *
+     * @param sentenceCount The number of sentences to generate. Defaults to a random number between `2` and `6`.
+     * @param sentenceCount.min The minimum number of sentences to generate. Defaults to `2`.
+     * @param sentenceCount.max The maximum number of sentences to generate. Defaults to `6`.
+     * @param separator The separator to add between sentences. Defaults to `' '`.
+     *
+     * @example
+     * faker.lorem.sentences() // 'Iste molestiae incidunt aliquam possimus reprehenderit eum corrupti. Deleniti modi voluptatem nostrum ut esse.'
+     * faker.lorem.sentences(2) // 'Maxime vel numquam quibusdam. Dignissimos ex molestias quos aut molestiae quam nihil occaecati maiores.'
+     * faker.lorem.sentences(2, '\n')
+     * // 'Et rerum a unde tempora magnam sit nisi.
+     * // Et perspiciatis ipsam omnis.'
+     * faker.lorem.sentences({ min: 1, max: 3 }) // 'Placeat ex natus tenetur repellendus repellendus iste. Optio nostrum veritatis.'
+     *
+     * @since 2.0.1
+     */
+    sentences(sentenceCount?: number | {
+        /**
+         * The minimum number of sentences to generate.
+         */
+        min: number;
+        /**
+         * The maximum number of sentences to generate.
+         */
+        max: number;
+    }, separator?: string): string;
+    /**
+     * Generates a paragraph with the given number of sentences.
+     *
+     * @param sentenceCount The number of sentences to generate. Defaults to `3`.
+     * @param sentenceCount.min The minimum number of sentences to generate.
+     * @param sentenceCount.max The maximum number of sentences to generate.
+     *
+     * @example
+     * faker.lorem.paragraph() // 'Non architecto nam unde sint. Ex tenetur dolor facere optio aut consequatur. Ea laudantium reiciendis repellendus.'
+     * faker.lorem.paragraph(2) // 'Animi possimus nemo consequuntur ut ea et tempore unde qui. Quis corporis esse occaecati.'
+     * faker.lorem.paragraph({ min: 1, max: 3 }) // 'Quis doloribus necessitatibus sint. Rerum accusamus impedit corporis porro.'
+     *
+     * @since 2.0.1
+     */
+    paragraph(sentenceCount?: number | {
+        /**
+         * The minimum number of sentences to generate.
+         */
+        min: number;
+        /**
+         * The maximum number of sentences to generate.
+         */
+        max: number;
+    }): string;
+    /**
+     * Generates the given number of paragraphs.
+     *
+     * @param paragraphCount The number of paragraphs to generate. Defaults to `3`.
+     * @param paragraphCount.min The minimum number of paragraphs to generate.
+     * @param paragraphCount.max The maximum number of paragraphs to generate.
+     * @param separator The separator to use. Defaults to `'\n'`.
+     *
+     * @example
+     * faker.lorem.paragraphs()
+     * // 'Beatae voluptatem dicta et assumenda fugit eaque quidem consequatur. Fuga unde provident. Id reprehenderit soluta facilis est laborum laborum. Illum aut non ut. Est nulla rem ipsa.
+     * // Voluptatibus quo pariatur est. Temporibus deleniti occaecati pariatur nemo est molestias voluptas. Doloribus commodi et et exercitationem vel et. Omnis inventore cum aut amet.
+     * // Sapiente deleniti et. Ducimus maiores eum. Rem dolorem itaque aliquam.'
+     *
+     * faker.lorem.paragraphs(5)
+     * // 'Quia hic sunt ducimus expedita quo impedit soluta. Quam impedit et ipsum optio. Unde dolores nulla nobis vero et aspernatur officiis.
+     * // Aliquam dolorem temporibus dolores voluptatem voluptatem qui nostrum quia. Sit hic facilis rerum eius. Beatae doloribus nesciunt iste ipsum.
+     * // Natus nam eum nulla voluptas molestiae fuga libero nihil voluptatibus. Sed quam numquam eum ipsam temporibus eaque ut et. Enim quas debitis quasi quis. Vitae et vitae.
+     * // Repellat voluptatem est laborum illo harum sed reprehenderit aut. Quo sit et. Exercitationem blanditiis totam velit ad dicta placeat.
+     * // Rerum non eum incidunt amet quo. Eaque laborum ut. Recusandae illo ab distinctio veritatis. Cum quis architecto ad maxime a.'
+     *
+     * faker.lorem.paragraphs(2, '<br/>\n')
+     * // 'Eos magnam aut qui accusamus. Sapiente quas culpa totam excepturi. Blanditiis totam distinctio occaecati dignissimos cumque atque qui officiis.<br/>
+     * // Nihil quis vel consequatur. Blanditiis commodi deserunt sunt animi dolorum. A optio porro hic dolorum fugit aut et sint voluptas. Minima ad sed ipsa est non dolores.'
+     *
+     * faker.lorem.paragraphs({ min: 1, max: 3 })
+     * // 'Eum nam fugiat laudantium.
+     * // Dignissimos tempore porro necessitatibus commodi nam.
+     * // Veniam at commodi iste perferendis totam dolorum corporis ipsam.'
+     *
+     * @since 2.0.1
+     */
+    paragraphs(paragraphCount?: number | {
+        /**
+         * The minimum number of paragraphs to generate.
+         */
+        min: number;
+        /**
+         * The maximum number of paragraphs to generate.
+         */
+        max: number;
+    }, separator?: string): string;
+    /**
+     * Generates a random text based on a random lorem method.
+     *
+     * @example
+     * faker.lorem.text() // 'Doloribus autem non quis vero quia.'
+     * faker.lorem.text()
+     * // 'Rerum eum reiciendis id ipsa hic dolore aut laborum provident.
+     * // Quis beatae quis corporis veritatis corrupti ratione delectus sapiente ut.
+     * // Quis ut dolor dolores facilis possimus tempore voluptates.
+     * // Iure nam officia optio cumque.
+     * // Dolor tempora iusto.'
+     *
+     * @since 3.1.0
+     */
+    text(): string;
+    /**
+     * Generates the given number lines of lorem separated by `'\n'`.
+     *
+     * @param lineCount The number of lines to generate. Defaults to a random number between `1` and `5`.
+     * @param lineCount.min The minimum number of lines to generate. Defaults to `1`.
+     * @param lineCount.max The maximum number of lines to generate. Defaults to `5`.
+     *
+     * @example
+     * faker.lorem.lines()
+     * // 'Rerum quia aliquam pariatur explicabo sint minima eos.
+     * // Voluptatem repellat consequatur deleniti qui quibusdam harum cumque.
+     * // Enim eveniet a qui.
+     * // Consectetur velit eligendi animi nostrum veritatis.'
+     *
+     * faker.lorem.lines()
+     * // 'Soluta deserunt eos quam reiciendis libero autem enim nam ut.
+     * // Voluptate aut aut.'
+     *
+     * faker.lorem.lines(2)
+     * // 'Quod quas nam quis impedit aut consequuntur.
+     * // Animi dolores aspernatur.'
+     *
+     * faker.lorem.lines({ min: 1, max: 3 })
+     * // 'Error dolorem natus quos eum consequatur necessitatibus.'
+     *
+     * @since 3.1.0
+     */
+    lines(lineCount?: number | {
+        /**
+         * The minimum number of lines to generate.
+         */
+        min: number;
+        /**
+         * The maximum number of lines to generate.
+         */
+        max: number;
+    }): string;
+}

package/dist/node_modules/@faker-js/faker/dist/types/modules/music/index.d.ts

@@ -0,0 +1,28 @@
+import { ModuleBase } from '../../internal/module-base';
+/**
+ * Module to generate music related entries.
+ *
+ * ### Overview
+ *
+ * Generate a random music genre with [`genre()`](https://fakerjs.dev/api/music.html#genre) or song name with [`songName()`](https://fakerjs.dev/api/music.html#songname). Both may be localized.
+ */
+export declare class MusicModule extends ModuleBase {
+    /**
+     * Returns a random music genre.
+     *
+     * @example
+     * faker.music.genre() // 'Reggae'
+     *
+     * @since 5.2.0
+     */
+    genre(): string;
+    /**
+     * Returns a random song name.
+     *
+     * @example
+     * faker.music.songName() // 'White Christmas'
+     *
+     * @since 7.1.0
+     */
+    songName(): string;
+}

package/dist/node_modules/@faker-js/faker/dist/types/modules/number/index.d.ts

@@ -0,0 +1,243 @@
+import { SimpleModuleBase } from '../../internal/module-base';
+/**
+ * Module to generate numbers of any kind.
+ *
+ * ### Overview
+ *
+ * For simple integers, use [`int()`](https://fakerjs.dev/api/number.html#int). For decimal/floating-point numbers, use [`float()`](https://fakerjs.dev/api/number.html#float).
+ *
+ * For numbers not in base-10, you can use [`hex()`](https://fakerjs.dev/api/number.html#hex), [`octal()`](https://fakerjs.dev/api/number.html#octal) and [`binary()`](https://fakerjs.dev/api/number.html#binary)`.
+ *
+ * ### Related modules
+ *
+ * - For numeric strings of a given length, use [`faker.string.numeric()`](https://fakerjs.dev/api/string.html#numeric).
+ * - For credit card numbers, use [`faker.finance.creditCardNumber()`](https://fakerjs.dev/api/finance.html#creditcardnumber).
+ */
+export declare class NumberModule extends SimpleModuleBase {
+    /**
+     * Returns a single random integer between zero and the given max value or the given range.
+     * The bounds are inclusive.
+     *
+     * @param options Maximum value or options object.
+     * @param options.min Lower bound for generated number. Defaults to `0`.
+     * @param options.max Upper bound for generated number. Defaults to `Number.MAX_SAFE_INTEGER`.
+     *
+     * @throws When `min` is greater than `max`.
+     * @throws When there are no integers between `min` and `max`.
+     *
+     * @see faker.string.numeric(): For generating a `string` of digits with a given length (range).
+     *
+     * @example
+     * faker.number.int() // 2900970162509863
+     * faker.number.int(100) // 52
+     * faker.number.int({ min: 1000000 }) // 2900970162509863
+     * faker.number.int({ max: 100 }) // 42
+     * faker.number.int({ min: 10, max: 100 }) // 57
+     *
+     * @since 8.0.0
+     */
+    int(options?: number | {
+        /**
+         * Lower bound for generated number.
+         *
+         * @default 0
+         */
+        min?: number;
+        /**
+         * Upper bound for generated number.
+         *
+         * @default Number.MAX_SAFE_INTEGER
+         */
+        max?: number;
+    }): number;
+    /**
+     * Returns a single random floating-point number, by default between `0.0` and `1.0`. To change the range, pass a `min` and `max` value. To limit the number of decimal places, pass a `multipleOf` or `fractionDigits` parameter.
+     *
+     * @param options Upper bound or options object.
+     * @param options.min Lower bound for generated number, inclusive. Defaults to `0.0`.
+     * @param options.max Upper bound for generated number, exclusive, unless `multipleOf`, `precision` or `fractionDigits` are passed. Defaults to `1.0`.
+     * @param options.precision Deprecated alias for `multipleOf`. Only one of `multipleOf`, `precision` or `fractionDigits` should be passed.
+     * @param options.multipleOf The generated number will be a multiple of this parameter. Only one of `multipleOf`, `precision` or `fractionDigits` should be passed.
+     * @param options.fractionDigits The maximum number of digits to appear after the decimal point, for example `2` will round to 2 decimal points.  Only one of `multipleOf`, `precision` or `fractionDigits` should be passed.
+     *
+     * @throws When `min` is greater than `max`.
+     * @throws When `precision` is negative.
+     * @throws When `multipleOf` is negative.
+     * @throws When `fractionDigits` is negative.
+     * @throws When `fractionDigits` and `multipleOf` is passed in the same options object.
+     *
+     * @example
+     * faker.number.float() // 0.5688541042618454
+     * faker.number.float(3) // 2.367973240558058
+     * faker.number.float({ max: 100 }) // 17.3687307164073
+     * faker.number.float({ min: 20, max: 30 }) // 23.94764115102589
+     * faker.number.float({ multipleOf: 0.25, min: 0, max:10 }) // 7.75
+     * faker.number.float({ fractionDigits: 1 }) // 0.9
+     * faker.number.float({ min: 10, max: 100, multipleOf: 0.02 }) // 35.42
+     * faker.number.float({ min: 10, max: 100, fractionDigits: 3 }) // 65.716
+     * faker.number.float({ min: 10, max: 100, multipleOf: 0.001 }) // 65.716 - same as above
+     *
+     * @since 8.0.0
+     */
+    float(options?: number | {
+        /**
+         * Lower bound for generated number, inclusive.
+         *
+         * @default 0.0
+         */
+        min?: number;
+        /**
+         * Upper bound for generated number, exclusive, unless `multipleOf`, `precision` or `fractionDigits` are passed.
+         *
+         * @default 1.0
+         */
+        max?: number;
+        /**
+         * The maximum number of digits to appear after the decimal point, for example `2` will round to 2 decimal points.  Only one of `multipleOf`, `precision` or `fractionDigits` should be passed.
+         */
+        fractionDigits?: number;
+        /**
+         * Deprecated alias for `multipleOf`. Only one of `multipleOf`, `precision` or `fractionDigits` should be passed.
+         *
+         * @deprecated Use `multipleOf` instead.
+         */
+        precision?: number;
+        /**
+         * The generated number will be a multiple of this parameter. Only one of `multipleOf`, `precision` or `fractionDigits` should be passed.
+         */
+        multipleOf?: number;
+    }): number;
+    /**
+     * Returns a [binary](https://en.wikipedia.org/wiki/Binary_number) number.
+     * The bounds are inclusive.
+     *
+     * @param options Maximum value or options object.
+     * @param options.min Lower bound for generated number. Defaults to `0`.
+     * @param options.max Upper bound for generated number. Defaults to `1`.
+     *
+     * @throws When `min` is greater than `max`.
+     * @throws When there are no integers between `min` and `max`.
+     *
+     * @see faker.string.binary(): For generating a `binary string` with a given length (range).
+     *
+     * @example
+     * faker.number.binary() // '1'
+     * faker.number.binary(255) // '110101'
+     * faker.number.binary({ min: 0, max: 65535 }) // '10110101'
+     *
+     * @since 8.0.0
+     */
+    binary(options?: number | {
+        /**
+         * Lower bound for generated number.
+         *
+         * @default 0
+         */
+        min?: number;
+        /**
+         * Upper bound for generated number.
+         *
+         * @default 1
+         */
+        max?: number;
+    }): string;
+    /**
+     * Returns an [octal](https://en.wikipedia.org/wiki/Octal) number.
+     * The bounds are inclusive.
+     *
+     * @param options Maximum value or options object.
+     * @param options.min Lower bound for generated number. Defaults to `0`.
+     * @param options.max Upper bound for generated number. Defaults to `7`.
+     *
+     * @throws When `min` is greater than `max`.
+     * @throws When there are no integers between `min` and `max`.
+     *
+     * @see faker.string.octal(): For generating an `octal string` with a given length (range).
+     *
+     * @example
+     * faker.number.octal() // '5'
+     * faker.number.octal(255) // '377'
+     * faker.number.octal({ min: 0, max: 65535 }) // '4766'
+     *
+     * @since 8.0.0
+     */
+    octal(options?: number | {
+        /**
+         * Lower bound for generated number.
+         *
+         * @default 0
+         */
+        min?: number;
+        /**
+         * Upper bound for generated number.
+         *
+         * @default 7
+         */
+        max?: number;
+    }): string;
+    /**
+     * Returns a lowercase [hexadecimal](https://en.wikipedia.org/wiki/Hexadecimal) number.
+     * The bounds are inclusive.
+     *
+     * @param options Maximum value or options object.
+     * @param options.min Lower bound for generated number. Defaults to `0`.
+     * @param options.max Upper bound for generated number. Defaults to `15`.
+     *
+     * @throws When `min` is greater than `max`.
+     * @throws When there are no integers between `min` and `max`.
+     *
+     * @example
+     * faker.number.hex() // 'b'
+     * faker.number.hex(255) // '9d'
+     * faker.number.hex({ min: 0, max: 65535 }) // 'af17'
+     *
+     * @since 8.0.0
+     */
+    hex(options?: number | {
+        /**
+         * Lower bound for generated number.
+         *
+         * @default 0
+         */
+        min?: number;
+        /**
+         * Upper bound for generated number.
+         *
+         * @default 15
+         */
+        max?: number;
+    }): string;
+    /**
+     * Returns a [BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#bigint_type) number.
+     * The bounds are inclusive.
+     *
+     * @param options Maximum value or options object.
+     * @param options.min Lower bound for generated bigint. Defaults to `0n`.
+     * @param options.max Upper bound for generated bigint. Defaults to `min + 999999999999999n`.
+     *
+     * @throws When `min` is greater than `max`.
+     *
+     * @example
+     * faker.number.bigInt() // 55422n
+     * faker.number.bigInt(100n) // 52n
+     * faker.number.bigInt({ min: 1000000n }) // 431433n
+     * faker.number.bigInt({ max: 100n }) // 42n
+     * faker.number.bigInt({ min: 10n, max: 100n }) // 36n
+     *
+     * @since 8.0.0
+     */
+    bigInt(options?: bigint | number | string | boolean | {
+        /**
+         * Lower bound for generated bigint.
+         *
+         * @default 0n
+         */
+        min?: bigint | number | string | boolean;
+        /**
+         * Upper bound for generated bigint.
+         *
+         * @default min + 999999999999999n
+         */
+        max?: bigint | number | string | boolean;
+    }): bigint;
+}