@eleven-am/faker
    Preparing search index...

    Variable fConst

    f: {
        address: (options?: AddressOptions) => AddressSchema;
        array: <T extends Schema<any>>(
            elementSchema: T,
            options?: ArrayOptions,
        ) => ArraySchema<Infer<T>>;
        avatar: (options?: AvatarOptions) => AvatarSchema;
        boolean: (options?: BooleanOptions) => BooleanSchema;
        creditCard: (options?: CreditCardOptions) => CreditCardSchema;
        custom: <T>(generatorFn: CustomGeneratorFn<T>) => Schema<T>;
        date: (options?: DateOptions) => DateSchema;
        dependent: <ParentType = unknown, S extends Schema<any> = Schema<unknown>>(
            schema: S,
            options: DependentOptions<ParentType>,
        ) => Schema<undefined | Infer<S>>;
        email: (options?: EmailOptions) => EmailSchema;
        enum: <T extends EnumValue>(values: readonly T[]) => Schema<T>;
        literal: <T extends LiteralValue>(value: T) => Schema<T>;
        locale: <S extends Schema<any>>(
            localeCode: string,
            schema: S,
        ) => Schema<Infer<S>>;
        name: (options?: NameOptions) => NameSchema;
        number: (options?: NumberOptions) => NumberSchema;
        object: <T extends SchemaShape>(shape: T) => Schema<ObjectOutputType<T>>;
        paragraph: (options?: ParagraphOptions) => ParagraphSchema;
        phone: (options?: PhoneOptions) => PhoneSchema;
        record: <K extends Schema<RecordKey>, V extends Schema<any>>(
            keySchema: K,
            valueSchema: V,
            options?: RecordOptions,
        ) => Schema<Record<Infer<K>, Infer<V>>>;
        reference: <RefT extends object>(
            options: ReferenceOptions<RefT>,
        ) => Schema<
            | ReferenceReturnType<RefT, undefined>
            | ReferenceReturnType<RefT, keyof RefT>,
        >;
        string: (options?: StringOptions) => StringSchema;
        tuple: <T extends TupleSchemaArray>(
            ...schemas: T,
        ) => Schema<TupleOutputType<T>>;
        union: <T extends SchemaArray>(...schemas: T) => Schema<Infer<T[number]>>;
        url: (options?: UrlOptions) => UrlSchema;
        uuid: () => Schema<string>;
    } = ...

    Type declaration