@types/faker

  • Version 5.5.6
  • Published
  • 21.3 kB
  • No dependencies
  • MIT license

Install

npm i @types/faker
yarn add @types/faker
pnpm add @types/faker

Overview

TypeScript definitions for faker

Index

Variables

variable fakerStatic

const fakerStatic: Faker.FakerStatic;

    Namespaces

    namespace faker

    module 'faker' {}

      variable fakerStatic

      const fakerStatic: Faker.FakerStatic;

        namespace Faker

        namespace Faker {}

          interface Address

          interface Address {}

            property city

            city: string;

              property geo

              geo: Geo;

                property state

                state: string;

                  property street

                  street: string;

                    property suite

                    suite: string;

                      property zipcode

                      zipcode: string;

                        interface Card

                        interface Card {}

                          property accountHistory

                          accountHistory: string[];

                            property address

                            address: FullAddress;

                              property company

                              company: Company;

                                property email

                                email: string;

                                  property name

                                  name: string;

                                    property phone

                                    phone: string;

                                      property posts

                                      posts: Post[];

                                        property username

                                        username: string;

                                          property website

                                          website: string;

                                            interface Company

                                            interface Company {}

                                              property bs

                                              bs: string;

                                                property catchPhrase

                                                catchPhrase: string;

                                                  property name

                                                  name: string;

                                                    interface ContextualCard

                                                    interface ContextualCard {}

                                                      property address

                                                      address: Address;

                                                        property avatar

                                                        avatar: string;

                                                          property company

                                                          company: Company;

                                                            property dob

                                                            dob: Date;

                                                              property email

                                                              email: string;

                                                                property name

                                                                name: string;

                                                                  property phone

                                                                  phone: string;

                                                                    property username

                                                                    username: string;

                                                                      property website

                                                                      website: string;

                                                                        interface FakerStatic

                                                                        interface FakerStatic {}

                                                                          property address

                                                                          address: {
                                                                          zipCodeByState(state: string): string;
                                                                          zipCode(format?: string): string;
                                                                          city(format?: string): string;
                                                                          cityName(): string;
                                                                          cityPrefix(): string;
                                                                          citySuffix(): string;
                                                                          streetName(): string;
                                                                          streetAddress(useFullAddress?: boolean): string;
                                                                          streetSuffix(): string;
                                                                          streetPrefix(): string;
                                                                          secondaryAddress(): string;
                                                                          county(): string;
                                                                          country(): string;
                                                                          countryCode(alphaCode?: string): string;
                                                                          state(useAbbr?: boolean): string;
                                                                          stateAbbr(): string;
                                                                          latitude(max?: number, min?: number, precision?: number): string;
                                                                          longitude(max?: number, min?: number, precision?: number): string;
                                                                          direction(useAbbr?: boolean): string;
                                                                          cardinalDirection(useAbbr?: boolean): string;
                                                                          ordinalDirection(useAbbr?: boolean): string;
                                                                          nearbyGPSCoordinate(
                                                                          coordinate?: ReadonlyArray<number | string>,
                                                                          radius?: number,
                                                                          isMetric?: boolean
                                                                          ): string[];
                                                                          timeZone(): string;
                                                                          };

                                                                            property commerce

                                                                            commerce: {
                                                                            color(): string;
                                                                            department(): string;
                                                                            productName(): string;
                                                                            price(min?: number, max?: number, dec?: number, symbol?: string): string;
                                                                            productAdjective(): string;
                                                                            productMaterial(): string;
                                                                            product(): string;
                                                                            productDescription(): string;
                                                                            };

                                                                              property company

                                                                              company: {
                                                                              suffixes(): string[];
                                                                              companyName(format?: number): string;
                                                                              companySuffix(): string;
                                                                              catchPhrase(): string;
                                                                              bs(): string;
                                                                              catchPhraseAdjective(): string;
                                                                              catchPhraseDescriptor(): string;
                                                                              catchPhraseNoun(): string;
                                                                              bsAdjective(): string;
                                                                              bsBuzz(): string;
                                                                              bsNoun(): string;
                                                                              };

                                                                                property database

                                                                                database: {
                                                                                column(): string;
                                                                                type(): string;
                                                                                collation(): string;
                                                                                engine(): string;
                                                                                };

                                                                                  property datatype

                                                                                  datatype: {
                                                                                  number(max?: number): number;
                                                                                  number(options?: { min?: number; max?: number; precision?: number }): number;
                                                                                  float(precision?: number): number;
                                                                                  float(options?: { min?: number; max?: number; precision?: number }): number;
                                                                                  datetime(max?: number): Date;
                                                                                  datetime(options?: { min?: number; max?: number }): Date;
                                                                                  string(length?: number): string;
                                                                                  uuid(): string;
                                                                                  boolean(): boolean;
                                                                                  hexaDecimal(count?: number): string;
                                                                                  json(): string;
                                                                                  array(length?: number): Array<string | number>;
                                                                                  };

                                                                                    property date

                                                                                    date: {
                                                                                    past(years?: number, refDate?: string | Date): Date;
                                                                                    future(years?: number, refDate?: string | Date): Date;
                                                                                    between(from: string | number | Date, to: string | Date): Date;
                                                                                    recent(days?: number, refDate?: string | Date): Date;
                                                                                    soon(days?: number, refDate?: string | Date): Date;
                                                                                    month(options?: { abbr?: boolean; context?: boolean }): string;
                                                                                    weekday(options?: { abbr?: boolean; context?: boolean }): string;
                                                                                    };

                                                                                      property finance

                                                                                      finance: {
                                                                                      account(length?: number): string;
                                                                                      accountName(): string;
                                                                                      routingNumber(): string;
                                                                                      mask(length?: number, parens?: boolean, elipsis?: boolean): string;
                                                                                      amount(min?: number, max?: number, dec?: number, symbol?: string): string;
                                                                                      transactionType(): string;
                                                                                      currencyCode(): string;
                                                                                      currencyName(): string;
                                                                                      currencySymbol(): string;
                                                                                      bitcoinAddress(): string;
                                                                                      iban(formatted?: boolean): string;
                                                                                      bic(): string;
                                                                                      litecoinAddress(): string;
                                                                                      creditCardNumber(provider?: string): string;
                                                                                      creditCardCVV(): string;
                                                                                      ethereumAddress(): string;
                                                                                      transactionDescription(): string;
                                                                                      };

                                                                                        property git

                                                                                        git: {
                                                                                        branch(): string;
                                                                                        commitEntry(options?: { merge: boolean }): string;
                                                                                        commitMessage(): string;
                                                                                        commitSha(): string;
                                                                                        shortSha(): string;
                                                                                        };

                                                                                          property hacker

                                                                                          hacker: {
                                                                                          abbreviation(): string;
                                                                                          adjective(): string;
                                                                                          noun(): string;
                                                                                          verb(): string;
                                                                                          ingverb(): string;
                                                                                          phrase(): string;
                                                                                          };

                                                                                            property helpers

                                                                                            helpers: {
                                                                                            randomize<T>(array: T[]): T;
                                                                                            randomize(): string;
                                                                                            slugify(string?: string): string;
                                                                                            replaceSymbolWithNumber(string?: string, symbol?: string): string;
                                                                                            replaceSymbols(string?: string): string;
                                                                                            replaceCreditCardSymbols(string?: string, symbol?: string): string;
                                                                                            repeatString(string: string, num?: number): string;
                                                                                            regexpStyleStringParse(string: string): string;
                                                                                            shuffle<T>(o: T[]): T[];
                                                                                            shuffle(): string[];
                                                                                            mustache(
                                                                                            str: string,
                                                                                            data: {
                                                                                            [key: string]:
                                                                                            | string
                                                                                            | ((substring: string, ...args: any[]) => string);
                                                                                            }
                                                                                            ): string;
                                                                                            createCard(): Card;
                                                                                            contextualCard(): ContextualCard;
                                                                                            userCard(): UserCard;
                                                                                            createTransaction(): Transaction;
                                                                                            };

                                                                                              property image

                                                                                              image: {
                                                                                              image(): string;
                                                                                              avatar(): string;
                                                                                              imageUrl(
                                                                                              width?: number,
                                                                                              height?: number,
                                                                                              category?: string,
                                                                                              randomize?: boolean,
                                                                                              https?: boolean
                                                                                              ): string;
                                                                                              abstract(width?: number, height?: number): string;
                                                                                              animals(width?: number, height?: number): string;
                                                                                              business(width?: number, height?: number): string;
                                                                                              cats(width?: number, height?: number): string;
                                                                                              city(width?: number, height?: number): string;
                                                                                              food(width?: number, height?: number): string;
                                                                                              nightlife(width?: number, height?: number): string;
                                                                                              fashion(width?: number, height?: number): string;
                                                                                              people(width?: number, height?: number): string;
                                                                                              nature(width?: number, height?: number): string;
                                                                                              sports(width?: number, height?: number): string;
                                                                                              technics(width?: number, height?: number): string;
                                                                                              transport(width?: number, height?: number): string;
                                                                                              dataUri(width?: number, height?: number, color?: string): string;
                                                                                              };

                                                                                                property internet

                                                                                                internet: {
                                                                                                avatar(): string;
                                                                                                email(firstName?: string, lastName?: string, provider?: string): string;
                                                                                                exampleEmail(firstName?: string, lastName?: string): string;
                                                                                                userName(firstName?: string, lastName?: string): string;
                                                                                                protocol(): string;
                                                                                                url(): string;
                                                                                                domainName(): string;
                                                                                                domainSuffix(): string;
                                                                                                domainWord(): string;
                                                                                                ip(): string;
                                                                                                ipv6(): string;
                                                                                                port(): number;
                                                                                                userAgent(): string;
                                                                                                color(
                                                                                                baseRed255?: number,
                                                                                                baseGreen255?: number,
                                                                                                baseBlue255?: number
                                                                                                ): string;
                                                                                                mac(sep?: string): string;
                                                                                                password(
                                                                                                len?: number,
                                                                                                memorable?: boolean,
                                                                                                pattern?: string | RegExp,
                                                                                                prefix?: string
                                                                                                ): string;
                                                                                                };

                                                                                                  property locale

                                                                                                  locale: string;

                                                                                                    property lorem

                                                                                                    lorem: {
                                                                                                    word(length?: number): string;
                                                                                                    words(num?: number): string;
                                                                                                    sentence(wordCount?: number, range?: number): string;
                                                                                                    slug(wordCount?: number): string;
                                                                                                    sentences(sentenceCount?: number): string;
                                                                                                    paragraph(sentenceCount?: number): string;
                                                                                                    paragraphs(paragraphCount?: number, separator?: string): string;
                                                                                                    text(times?: number): string;
                                                                                                    lines(lineCount?: number): string;
                                                                                                    };

                                                                                                      property music

                                                                                                      music: {
                                                                                                      genre(): string;
                                                                                                      };

                                                                                                        property name

                                                                                                        name: {
                                                                                                        firstName(gender?: number): string;
                                                                                                        lastName(gender?: number): string;
                                                                                                        middleName(gender?: number): string;
                                                                                                        findName(firstName?: string, lastName?: string, gender?: number): string;
                                                                                                        jobTitle(): string;
                                                                                                        gender(): string;
                                                                                                        prefix(): string;
                                                                                                        suffix(): string;
                                                                                                        title(): string;
                                                                                                        jobDescriptor(): string;
                                                                                                        jobArea(): string;
                                                                                                        jobType(): string;
                                                                                                        };

                                                                                                          property phone

                                                                                                          phone: {
                                                                                                          phoneNumber(format?: string): string;
                                                                                                          phoneNumberFormat(phoneFormatsArrayIndex?: number): string;
                                                                                                          phoneFormats(): string;
                                                                                                          };

                                                                                                            property random

                                                                                                            random: {
                                                                                                            /** @deprecated faker.random.number is now located in faker.datatype.number */
                                                                                                            number(max?: number): number;
                                                                                                            /** @deprecated faker.random.number is now located in faker.datatype.number */
                                                                                                            number(options?: { min?: number; max?: number; precision?: number }): number;
                                                                                                            /** @deprecated faker.random.float is now located in faker.datatype.float */
                                                                                                            float(max?: number): number;
                                                                                                            /** @deprecated faker.random.float is now located in faker.datatype.float */
                                                                                                            float(options?: { min?: number; max?: number; precision?: number }): number;
                                                                                                            arrayElement(): string;
                                                                                                            arrayElement<T>(array: T[]): T;
                                                                                                            arrayElement<T>(array: ReadonlyArray<T>): T;
                                                                                                            arrayElements(count?: number): string[];
                                                                                                            arrayElements<T>(array: T[], count?: number): T[];
                                                                                                            arrayElements<T>(array: ReadonlyArray<T>, count?: number): ReadonlyArray<T>;
                                                                                                            objectElement(object?: { [key: string]: any }, field?: 'key'): string;
                                                                                                            objectElement<T>(object?: { [key: string]: T }, field?: any): T;
                                                                                                            /** @deprecated faker.random.uuid is now located in faker.datatype.uuid */
                                                                                                            uuid(): string;
                                                                                                            /** @deprecated faker.random.boolean is now located in faker.datatype.boolean */
                                                                                                            boolean(): boolean;
                                                                                                            word(type?: string): string;
                                                                                                            words(count?: number): string;
                                                                                                            image(): string;
                                                                                                            locale(): string;
                                                                                                            alpha(options?: { count?: number; upcase?: boolean }): string;
                                                                                                            alphaNumeric(count?: number): string;
                                                                                                            /** @deprecated faker.random.hexaDecimal is now located in faker.datatype.hexaDecimal */
                                                                                                            hexaDecimal(count?: number): string;
                                                                                                            };

                                                                                                              property seedValue

                                                                                                              seedValue?: number;

                                                                                                                property system

                                                                                                                system: {
                                                                                                                fileName(): string;
                                                                                                                commonFileName(ext?: string): string;
                                                                                                                mimeType(): string;
                                                                                                                commonFileType(): string;
                                                                                                                commonFileExt(): string;
                                                                                                                fileType(): string;
                                                                                                                fileExt(mimeType?: string): string;
                                                                                                                directoryPath(): string;
                                                                                                                filePath(): string;
                                                                                                                semver(): string;
                                                                                                                };

                                                                                                                  property time

                                                                                                                  time: {
                                                                                                                  recent(): number;
                                                                                                                  recent(outputType: 'unix'): number;
                                                                                                                  recent(outputType: 'abbr' | 'wide'): string;
                                                                                                                  };

                                                                                                                    property vehicle

                                                                                                                    vehicle: {
                                                                                                                    vehicle(): string;
                                                                                                                    manufacturer(): string;
                                                                                                                    model(): string;
                                                                                                                    type(): string;
                                                                                                                    fuel(): string;
                                                                                                                    vin(): string;
                                                                                                                    color(): string;
                                                                                                                    vrm(): string;
                                                                                                                    bicycle(): string;
                                                                                                                    };

                                                                                                                      method fake

                                                                                                                      fake: (str: string) => string;

                                                                                                                        method seed

                                                                                                                        seed: (value: number) => void;

                                                                                                                          method setLocale

                                                                                                                          setLocale: (locale: string) => void;

                                                                                                                            method unique

                                                                                                                            unique: <T extends (...args: any) => any>(
                                                                                                                            method: T,
                                                                                                                            args?: Parameters<T>,
                                                                                                                            opts?: { maxTime?: number; maxRetries?: number }
                                                                                                                            ) => ReturnType<T>;

                                                                                                                              interface FullAddress

                                                                                                                              interface FullAddress {}

                                                                                                                                property city

                                                                                                                                city: string;

                                                                                                                                  property county

                                                                                                                                  county: string;

                                                                                                                                    property geo

                                                                                                                                    geo: Geo;

                                                                                                                                      property state

                                                                                                                                      state: string;

                                                                                                                                        property streetA

                                                                                                                                        streetA: string;

                                                                                                                                          property streetB

                                                                                                                                          streetB: string;

                                                                                                                                            property streetC

                                                                                                                                            streetC: string;

                                                                                                                                              property streetD

                                                                                                                                              streetD: string;

                                                                                                                                                property zipcode

                                                                                                                                                zipcode: string;

                                                                                                                                                  interface Geo

                                                                                                                                                  interface Geo {}

                                                                                                                                                    property lat

                                                                                                                                                    lat: string;

                                                                                                                                                      property lng

                                                                                                                                                      lng: string;

                                                                                                                                                        interface Post

                                                                                                                                                        interface Post {}

                                                                                                                                                          property paragraph

                                                                                                                                                          paragraph: string;

                                                                                                                                                            property sentence

                                                                                                                                                            sentence: string;

                                                                                                                                                              property sentences

                                                                                                                                                              sentences: string;

                                                                                                                                                                property words

                                                                                                                                                                words: string;

                                                                                                                                                                  interface Transaction

                                                                                                                                                                  interface Transaction {}

                                                                                                                                                                    property account

                                                                                                                                                                    account: string;

                                                                                                                                                                      property amount

                                                                                                                                                                      amount: string;

                                                                                                                                                                        property business

                                                                                                                                                                        business: string;

                                                                                                                                                                          property date

                                                                                                                                                                          date: Date;

                                                                                                                                                                            property name

                                                                                                                                                                            name: string;

                                                                                                                                                                              property type

                                                                                                                                                                              type: string;

                                                                                                                                                                                interface UserCard

                                                                                                                                                                                interface UserCard {}

                                                                                                                                                                                  property address

                                                                                                                                                                                  address: Address;

                                                                                                                                                                                    property company

                                                                                                                                                                                    company: Company;

                                                                                                                                                                                      property email

                                                                                                                                                                                      email: string;

                                                                                                                                                                                        property name

                                                                                                                                                                                        name: string;

                                                                                                                                                                                          property phone

                                                                                                                                                                                          phone: string;

                                                                                                                                                                                            property username

                                                                                                                                                                                            username: string;

                                                                                                                                                                                              property website

                                                                                                                                                                                              website: string;

                                                                                                                                                                                                namespace faker/locale/ar

                                                                                                                                                                                                module 'faker/locale/ar' {}

                                                                                                                                                                                                  variable fakerStatic

                                                                                                                                                                                                  const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                    namespace faker/locale/az

                                                                                                                                                                                                    module 'faker/locale/az' {}

                                                                                                                                                                                                      variable fakerStatic

                                                                                                                                                                                                      const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                        namespace faker/locale/cz

                                                                                                                                                                                                        module 'faker/locale/cz' {}

                                                                                                                                                                                                          variable fakerStatic

                                                                                                                                                                                                          const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                            namespace faker/locale/de

                                                                                                                                                                                                            module 'faker/locale/de' {}

                                                                                                                                                                                                              variable fakerStatic

                                                                                                                                                                                                              const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                namespace faker/locale/de_AT

                                                                                                                                                                                                                module 'faker/locale/de_AT' {}

                                                                                                                                                                                                                  variable fakerStatic

                                                                                                                                                                                                                  const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                    namespace faker/locale/de_CH

                                                                                                                                                                                                                    module 'faker/locale/de_CH' {}

                                                                                                                                                                                                                      variable fakerStatic

                                                                                                                                                                                                                      const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                        namespace faker/locale/en

                                                                                                                                                                                                                        module 'faker/locale/en' {}

                                                                                                                                                                                                                          variable fakerStatic

                                                                                                                                                                                                                          const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                            namespace faker/locale/en_AU

                                                                                                                                                                                                                            module 'faker/locale/en_AU' {}

                                                                                                                                                                                                                              variable fakerStatic

                                                                                                                                                                                                                              const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                namespace faker/locale/en_AU_ocker

                                                                                                                                                                                                                                module 'faker/locale/en_AU_ocker' {}

                                                                                                                                                                                                                                  variable fakerStatic

                                                                                                                                                                                                                                  const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                    namespace faker/locale/en_BORK

                                                                                                                                                                                                                                    module 'faker/locale/en_BORK' {}

                                                                                                                                                                                                                                      variable fakerStatic

                                                                                                                                                                                                                                      const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                        namespace faker/locale/en_CA

                                                                                                                                                                                                                                        module 'faker/locale/en_CA' {}

                                                                                                                                                                                                                                          variable fakerStatic

                                                                                                                                                                                                                                          const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                            namespace faker/locale/en_GB

                                                                                                                                                                                                                                            module 'faker/locale/en_GB' {}

                                                                                                                                                                                                                                              variable fakerStatic

                                                                                                                                                                                                                                              const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                namespace faker/locale/en_IE

                                                                                                                                                                                                                                                module 'faker/locale/en_IE' {}

                                                                                                                                                                                                                                                  variable fakerStatic

                                                                                                                                                                                                                                                  const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                    namespace faker/locale/en_IND

                                                                                                                                                                                                                                                    module 'faker/locale/en_IND' {}

                                                                                                                                                                                                                                                      variable fakerStatic

                                                                                                                                                                                                                                                      const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                        namespace faker/locale/en_US

                                                                                                                                                                                                                                                        module 'faker/locale/en_US' {}

                                                                                                                                                                                                                                                          variable fakerStatic

                                                                                                                                                                                                                                                          const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                            namespace faker/locale/en_ZA

                                                                                                                                                                                                                                                            module 'faker/locale/en_ZA' {}

                                                                                                                                                                                                                                                              variable fakerStatic

                                                                                                                                                                                                                                                              const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                namespace faker/locale/es

                                                                                                                                                                                                                                                                module 'faker/locale/es' {}

                                                                                                                                                                                                                                                                  variable fakerStatic

                                                                                                                                                                                                                                                                  const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                    namespace faker/locale/es_MX

                                                                                                                                                                                                                                                                    module 'faker/locale/es_MX' {}

                                                                                                                                                                                                                                                                      variable fakerStatic

                                                                                                                                                                                                                                                                      const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                        namespace faker/locale/fa

                                                                                                                                                                                                                                                                        module 'faker/locale/fa' {}

                                                                                                                                                                                                                                                                          variable fakerStatic

                                                                                                                                                                                                                                                                          const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                            namespace faker/locale/fi

                                                                                                                                                                                                                                                                            module 'faker/locale/fi' {}

                                                                                                                                                                                                                                                                              variable fakerStatic

                                                                                                                                                                                                                                                                              const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                namespace faker/locale/fr

                                                                                                                                                                                                                                                                                module 'faker/locale/fr' {}

                                                                                                                                                                                                                                                                                  variable fakerStatic

                                                                                                                                                                                                                                                                                  const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                    namespace faker/locale/fr_CA

                                                                                                                                                                                                                                                                                    module 'faker/locale/fr_CA' {}

                                                                                                                                                                                                                                                                                      variable fakerStatic

                                                                                                                                                                                                                                                                                      const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                        namespace faker/locale/fr_CH

                                                                                                                                                                                                                                                                                        module 'faker/locale/fr_CH' {}

                                                                                                                                                                                                                                                                                          variable fakerStatic

                                                                                                                                                                                                                                                                                          const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                            namespace faker/locale/ge

                                                                                                                                                                                                                                                                                            module 'faker/locale/ge' {}

                                                                                                                                                                                                                                                                                              variable fakerStatic

                                                                                                                                                                                                                                                                                              const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                namespace faker/locale/id_ID

                                                                                                                                                                                                                                                                                                module 'faker/locale/id_ID' {}

                                                                                                                                                                                                                                                                                                  variable fakerStatic

                                                                                                                                                                                                                                                                                                  const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                    namespace faker/locale/it

                                                                                                                                                                                                                                                                                                    module 'faker/locale/it' {}

                                                                                                                                                                                                                                                                                                      variable fakerStatic

                                                                                                                                                                                                                                                                                                      const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                        namespace faker/locale/ja

                                                                                                                                                                                                                                                                                                        module 'faker/locale/ja' {}

                                                                                                                                                                                                                                                                                                          variable fakerStatic

                                                                                                                                                                                                                                                                                                          const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                            namespace faker/locale/ko

                                                                                                                                                                                                                                                                                                            module 'faker/locale/ko' {}

                                                                                                                                                                                                                                                                                                              variable fakerStatic

                                                                                                                                                                                                                                                                                                              const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                namespace faker/locale/nb_NO

                                                                                                                                                                                                                                                                                                                module 'faker/locale/nb_NO' {}

                                                                                                                                                                                                                                                                                                                  variable fakerStatic

                                                                                                                                                                                                                                                                                                                  const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                    namespace faker/locale/nep

                                                                                                                                                                                                                                                                                                                    module 'faker/locale/nep' {}

                                                                                                                                                                                                                                                                                                                      variable fakerStatic

                                                                                                                                                                                                                                                                                                                      const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                        namespace faker/locale/nl

                                                                                                                                                                                                                                                                                                                        module 'faker/locale/nl' {}

                                                                                                                                                                                                                                                                                                                          variable fakerStatic

                                                                                                                                                                                                                                                                                                                          const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                            namespace faker/locale/nl_BE

                                                                                                                                                                                                                                                                                                                            module 'faker/locale/nl_BE' {}

                                                                                                                                                                                                                                                                                                                              variable fakerStatic

                                                                                                                                                                                                                                                                                                                              const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                                namespace faker/locale/pl

                                                                                                                                                                                                                                                                                                                                module 'faker/locale/pl' {}

                                                                                                                                                                                                                                                                                                                                  variable fakerStatic

                                                                                                                                                                                                                                                                                                                                  const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                                    namespace faker/locale/pt_BR

                                                                                                                                                                                                                                                                                                                                    module 'faker/locale/pt_BR' {}

                                                                                                                                                                                                                                                                                                                                      variable fakerStatic

                                                                                                                                                                                                                                                                                                                                      const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                                        namespace faker/locale/pt_PT

                                                                                                                                                                                                                                                                                                                                        module 'faker/locale/pt_PT' {}

                                                                                                                                                                                                                                                                                                                                          variable fakerStatic

                                                                                                                                                                                                                                                                                                                                          const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                                            namespace faker/locale/ro

                                                                                                                                                                                                                                                                                                                                            module 'faker/locale/ro' {}

                                                                                                                                                                                                                                                                                                                                              variable fakerStatic

                                                                                                                                                                                                                                                                                                                                              const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                                                namespace faker/locale/ru

                                                                                                                                                                                                                                                                                                                                                module 'faker/locale/ru' {}

                                                                                                                                                                                                                                                                                                                                                  variable fakerStatic

                                                                                                                                                                                                                                                                                                                                                  const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                                                    namespace faker/locale/sk

                                                                                                                                                                                                                                                                                                                                                    module 'faker/locale/sk' {}

                                                                                                                                                                                                                                                                                                                                                      variable fakerStatic

                                                                                                                                                                                                                                                                                                                                                      const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                                                        namespace faker/locale/sv

                                                                                                                                                                                                                                                                                                                                                        module 'faker/locale/sv' {}

                                                                                                                                                                                                                                                                                                                                                          variable fakerStatic

                                                                                                                                                                                                                                                                                                                                                          const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                                                            namespace faker/locale/tr

                                                                                                                                                                                                                                                                                                                                                            module 'faker/locale/tr' {}

                                                                                                                                                                                                                                                                                                                                                              variable fakerStatic

                                                                                                                                                                                                                                                                                                                                                              const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                                                                namespace faker/locale/uk

                                                                                                                                                                                                                                                                                                                                                                module 'faker/locale/uk' {}

                                                                                                                                                                                                                                                                                                                                                                  variable fakerStatic

                                                                                                                                                                                                                                                                                                                                                                  const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                                                                    namespace faker/locale/vi

                                                                                                                                                                                                                                                                                                                                                                    module 'faker/locale/vi' {}

                                                                                                                                                                                                                                                                                                                                                                      variable fakerStatic

                                                                                                                                                                                                                                                                                                                                                                      const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                                                                        namespace faker/locale/zh_CN

                                                                                                                                                                                                                                                                                                                                                                        module 'faker/locale/zh_CN' {}

                                                                                                                                                                                                                                                                                                                                                                          variable fakerStatic

                                                                                                                                                                                                                                                                                                                                                                          const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                                                                            namespace faker/locale/zh_TW

                                                                                                                                                                                                                                                                                                                                                                            module 'faker/locale/zh_TW' {}

                                                                                                                                                                                                                                                                                                                                                                              variable fakerStatic

                                                                                                                                                                                                                                                                                                                                                                              const fakerStatic: Faker.FakerStatic;

                                                                                                                                                                                                                                                                                                                                                                                Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                Badge

                                                                                                                                                                                                                                                                                                                                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/faker.

                                                                                                                                                                                                                                                                                                                                                                                • Markdown
                                                                                                                                                                                                                                                                                                                                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/faker)
                                                                                                                                                                                                                                                                                                                                                                                • HTML
                                                                                                                                                                                                                                                                                                                                                                                  <a href="https://www.jsdocs.io/package/@types/faker"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>