code:
// ==================================================================================================
// JSON Schema Draft 04
// ==================================================================================================

/**
 * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1
 */
export type JSONSchema4TypeName =
    | "string" //
    | "number"
    | "integer"
    | "boolean"
    | "object"
    | "array"
    | "null"
    | "any";

/**
 * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-3.5
 */
export type JSONSchema4Type =
    | string //
    | number
    | boolean
    | JSONSchema4Object
    | JSONSchema4Array
    | null;

// Workaround for infinite type recursion
export interface JSONSchema4Object {
    [key: string]: JSONSchema4Type;
}

// Workaround for infinite type recursion
// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
export interface JSONSchema4Array extends Array<JSONSchema4Type> {}

/**
 * Meta schema
 *
 * Recommended values:
 * - 'http://json-schema.org/schema#'
 * - 'http://json-schema.org/hyper-schema#'
 * - 'http://json-schema.org/draft-04/schema#'
 * - 'http://json-schema.org/draft-04/hyper-schema#'
 * - 'http://json-schema.org/draft-03/schema#'
 * - 'http://json-schema.org/draft-03/hyper-schema#'
 *
 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
 */
export type JSONSchema4Version = string;

/**
 * JSON Schema V4
 * @see https://tools.ietf.org/html/draft-zyp-json-schema-04
 */
export interface JSONSchema4 {
    id?: string | undefined;
    $ref?: string | undefined;
    $schema?: JSONSchema4Version | undefined;

    /**
     * This attribute is a string that provides a short description of the
     * instance property.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.21
     */
    title?: string | undefined;

    /**
     * This attribute is a string that provides a full description of the of
     * purpose the instance property.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.22
     */
    description?: string | undefined;

    default?: JSONSchema4Type | undefined;
    multipleOf?: number | undefined;
    maximum?: number | undefined;
    exclusiveMaximum?: boolean | undefined;
    minimum?: number | undefined;
    exclusiveMinimum?: boolean | undefined;
    maxLength?: number | undefined;
    minLength?: number | undefined;
    pattern?: string | undefined;

    /**
     * May only be defined when "items" is defined, and is a tuple of JSONSchemas.
     *
     * This provides a definition for additional items in an array instance
     * when tuple definitions of the items is provided.  This can be false
     * to indicate additional items in the array are not allowed, or it can
     * be a schema that defines the schema of the additional items.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.6
     */
    additionalItems?: boolean | JSONSchema4 | undefined;

    /**
     * This attribute defines the allowed items in an instance array, and
     * MUST be a schema or an array of schemas.  The default value is an
     * empty schema which allows any value for items in the instance array.
     *
     * When this attribute value is a schema and the instance value is an
     * array, then all the items in the array MUST be valid according to the
     * schema.
     *
     * When this attribute value is an array of schemas and the instance
     * value is an array, each position in the instance array MUST conform
     * to the schema in the corresponding position for this array.  This
     * called tuple typing.  When tuple typing is used, additional items are
     * allowed, disallowed, or constrained by the "additionalItems"
     * (Section 5.6) attribute using the same rules as
     * "additionalProperties" (Section 5.4) for objects.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5
     */
    items?: JSONSchema4 | JSONSchema4[] | undefined;

    maxItems?: number | undefined;
    minItems?: number | undefined;
    uniqueItems?: boolean | undefined;
    maxProperties?: number | undefined;
    minProperties?: number | undefined;

    /**
     * This attribute indicates if the instance must have a value, and not
     * be undefined. This is false by default, making the instance
     * optional.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.7
     */
    required?: boolean | string[] | undefined;

    /**
     * This attribute defines a schema for all properties that are not
     * explicitly defined in an object type definition. If specified, the
     * value MUST be a schema or a boolean. If false is provided, no
     * additional properties are allowed beyond the properties defined in
     * the schema. The default value is an empty schema which allows any
     * value for additional properties.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.4
     */
    additionalProperties?: boolean | JSONSchema4 | undefined;

    definitions?: {
        [k: string]: JSONSchema4;
    } | undefined;

    /**
     * This attribute is an object with property definitions that define the
     * valid values of instance object property values. When the instance
     * value is an object, the property values of the instance object MUST
     * conform to the property definitions in this object. In this object,
     * each property definition's value MUST be a schema, and the property's
     * name MUST be the name of the instance property that it defines.  The
     * instance property value MUST be valid according to the schema from
     * the property definition. Properties are considered unordered, the
     * order of the instance properties MAY be in any order.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.2
     */
    properties?: {
        [k: string]: JSONSchema4;
    } | undefined;

    /**
     * This attribute is an object that defines the schema for a set of
     * property names of an object instance. The name of each property of
     * this attribute's object is a regular expression pattern in the ECMA
     * 262/Perl 5 format, while the value is a schema. If the pattern
     * matches the name of a property on the instance object, the value of
     * the instance's property MUST be valid against the pattern name's
     * schema value.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.3
     */
    patternProperties?: {
        [k: string]: JSONSchema4;
    } | undefined;
    dependencies?: {
        [k: string]: JSONSchema4 | string[];
    } | undefined;

    /**
     * This provides an enumeration of all possible values that are valid
     * for the instance property. This MUST be an array, and each item in
     * the array represents a possible value for the instance value. If
     * this attribute is defined, the instance value MUST be one of the
     * values in the array in order for the schema to be valid.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
     */
    enum?: JSONSchema4Type[] | undefined;

    /**
     * A single type, or a union of simple types
     */
    type?: JSONSchema4TypeName | JSONSchema4TypeName[] | undefined;

    allOf?: JSONSchema4[] | undefined;
    anyOf?: JSONSchema4[] | undefined;
    oneOf?: JSONSchema4[] | undefined;
    not?: JSONSchema4 | undefined;

    /**
     * The value of this property MUST be another schema which will provide
     * a base schema which the current schema will inherit from.  The
     * inheritance rules are such that any instance that is valid according
     * to the current schema MUST be valid according to the referenced
     * schema.  This MAY also be an array, in which case, the instance MUST
     * be valid for all the schemas in the array.  A schema that extends
     * another schema MAY define additional attributes, constrain existing
     * attributes, or add other constraints.
     *
     * Conceptually, the behavior of extends can be seen as validating an
     * instance against all constraints in the extending schema as well as
     * the extended schema(s).
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.26
     */
    extends?: string | string[] | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-5.6
     */
    [k: string]: any;

    format?: string | undefined;
}

// ==================================================================================================
// JSON Schema Draft 06
// ==================================================================================================

export type JSONSchema6TypeName =
    | "string" //
    | "number"
    | "integer"
    | "boolean"
    | "object"
    | "array"
    | "null"
    | "any";

export type JSONSchema6Type =
    | string //
    | number
    | boolean
    | JSONSchema6Object
    | JSONSchema6Array
    | null;

// Workaround for infinite type recursion
export interface JSONSchema6Object {
    [key: string]: JSONSchema6Type;
}

// Workaround for infinite type recursion
// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
export interface JSONSchema6Array extends Array<JSONSchema6Type> {}

/**
 * Meta schema
 *
 * Recommended values:
 * - 'http://json-schema.org/schema#'
 * - 'http://json-schema.org/hyper-schema#'
 * - 'http://json-schema.org/draft-06/schema#'
 * - 'http://json-schema.org/draft-06/hyper-schema#'
 *
 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
 */
export type JSONSchema6Version = string;

/**
 * JSON Schema V6
 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01
 */
export type JSONSchema6Definition = JSONSchema6 | boolean;
export interface JSONSchema6 {
    $id?: string | undefined;
    $ref?: string | undefined;
    $schema?: JSONSchema6Version | undefined;

    /**
     * Must be strictly greater than 0.
     * A numeric instance is valid only if division by this keyword's value results in an integer.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.1
     */
    multipleOf?: number | undefined;

    /**
     * Representing an inclusive upper limit for a numeric instance.
     * This keyword validates only if the instance is less than or exactly equal to "maximum".
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.2
     */
    maximum?: number | undefined;

    /**
     * Representing an exclusive upper limit for a numeric instance.
     * This keyword validates only if the instance is strictly less than (not equal to) to "exclusiveMaximum".
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.3
     */
    exclusiveMaximum?: number | undefined;

    /**
     * Representing an inclusive lower limit for a numeric instance.
     * This keyword validates only if the instance is greater than or exactly equal to "minimum".
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.4
     */
    minimum?: number | undefined;

    /**
     * Representing an exclusive lower limit for a numeric instance.
     * This keyword validates only if the instance is strictly greater than (not equal to) to "exclusiveMinimum".
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.5
     */
    exclusiveMinimum?: number | undefined;

    /**
     * Must be a non-negative integer.
     * A string instance is valid against this keyword if its length is less than, or equal to, the value of this keyword.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.6
     */
    maxLength?: number | undefined;

    /**
     * Must be a non-negative integer.
     * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.
     * Omitting this keyword has the same behavior as a value of 0.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.7
     */
    minLength?: number | undefined;

    /**
     * Should be a valid regular expression, according to the ECMA 262 regular expression dialect.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.8
     */
    pattern?: string | undefined;

    /**
     * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
     * Omitting this keyword has the same behavior as an empty schema.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.9
     */
    items?: JSONSchema6Definition | JSONSchema6Definition[] | undefined;

    /**
     * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
     * If "items" is an array of schemas, validation succeeds if every instance element
     * at a position greater than the size of "items" validates against "additionalItems".
     * Otherwise, "additionalItems" MUST be ignored, as the "items" schema
     * (possibly the default value of an empty schema) is applied to all elements.
     * Omitting this keyword has the same behavior as an empty schema.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.10
     */
    additionalItems?: JSONSchema6Definition | undefined;

    /**
     * Must be a non-negative integer.
     * An array instance is valid against "maxItems" if its size is less than, or equal to, the value of this keyword.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.11
     */
    maxItems?: number | undefined;

    /**
     * Must be a non-negative integer.
     * An array instance is valid against "maxItems" if its size is greater than, or equal to, the value of this keyword.
     * Omitting this keyword has the same behavior as a value of 0.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.12
     */
    minItems?: number | undefined;

    /**
     * If this keyword has boolean value false, the instance validates successfully.
     * If it has boolean value true, the instance validates successfully if all of its elements are unique.
     * Omitting this keyword has the same behavior as a value of false.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.13
     */
    uniqueItems?: boolean | undefined;

    /**
     * An array instance is valid against "contains" if at least one of its elements is valid against the given schema.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.14
     */
    contains?: JSONSchema6Definition | undefined;

    /**
     * Must be a non-negative integer.
     * An object instance is valid against "maxProperties" if its number of properties is less than, or equal to, the value of this keyword.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.15
     */
    maxProperties?: number | undefined;

    /**
     * Must be a non-negative integer.
     * An object instance is valid against "maxProperties" if its number of properties is greater than,
     * or equal to, the value of this keyword.
     * Omitting this keyword has the same behavior as a value of 0.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.16
     */
    minProperties?: number | undefined;

    /**
     * Elements of this array must be unique.
     * An object instance is valid against this keyword if every item in the array is the name of a property in the instance.
     * Omitting this keyword has the same behavior as an empty array.
     *
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.17
     */
    required?: string[] | undefined;

    /**
     * This keyword determines how child instances validate for objects, and does not directly validate the immediate instance itself.
     * Validation succeeds if, for each name that appears in both the instance and as a name within this keyword's value,
     * the child instance for that name successfully validates against the corresponding schema.
     * Omitting this keyword has the same behavior as an empty object.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.18
     */
    properties?: {
        [k: string]: JSONSchema6Definition;
    } | undefined;

    /**
     * This attribute is an object that defines the schema for a set of property names of an object instance.
     * The name of each property of this attribute's object is a regular expression pattern in the ECMA 262, while the value is a schema.
     * If the pattern matches the name of a property on the instance object, the value of the instance's property
     * MUST be valid against the pattern name's schema value.
     * Omitting this keyword has the same behavior as an empty object.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.19
     */
    patternProperties?: {
        [k: string]: JSONSchema6Definition;
    } | undefined;

    /**
     * This attribute defines a schema for all properties that are not explicitly defined in an object type definition.
     * If specified, the value MUST be a schema or a boolean.
     * If false is provided, no additional properties are allowed beyond the properties defined in the schema.
     * The default value is an empty schema which allows any value for additional properties.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.20
     */
    additionalProperties?: JSONSchema6Definition | undefined;

    /**
     * This keyword specifies rules that are evaluated if the instance is an object and contains a certain property.
     * Each property specifies a dependency.
     * If the dependency value is an array, each element in the array must be unique.
     * Omitting this keyword has the same behavior as an empty object.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.21
     */
    dependencies?: {
        [k: string]: JSONSchema6Definition | string[];
    } | undefined;

    /**
     * Takes a schema which validates the names of all properties rather than their values.
     * Note the property name that the schema is testing will always be a string.
     * Omitting this keyword has the same behavior as an empty schema.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.22
     */
    propertyNames?: JSONSchema6Definition | undefined;

    /**
     * This provides an enumeration of all possible values that are valid
     * for the instance property. This MUST be an array, and each item in
     * the array represents a possible value for the instance value. If
     * this attribute is defined, the instance value MUST be one of the
     * values in the array in order for the schema to be valid.
     *
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.23
     */
    enum?: JSONSchema6Type[] | undefined;

    /**
     * More readable form of a one-element "enum"
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.24
     */
    const?: JSONSchema6Type | undefined;

    /**
     * A single type, or a union of simple types
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.25
     */
    type?: JSONSchema6TypeName | JSONSchema6TypeName[] | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.26
     */
    allOf?: JSONSchema6Definition[] | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.27
     */
    anyOf?: JSONSchema6Definition[] | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.28
     */
    oneOf?: JSONSchema6Definition[] | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.29
     */
    not?: JSONSchema6Definition | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.1
     */
    definitions?: {
        [k: string]: JSONSchema6Definition;
    } | undefined;

    /**
     * This attribute is a string that provides a short description of the instance property.
     *
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
     */
    title?: string | undefined;

    /**
     * This attribute is a string that provides a full description of the of purpose the instance property.
     *
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
     */
    description?: string | undefined;

    /**
     * This keyword can be used to supply a default JSON value associated with a particular schema.
     * It is RECOMMENDED that a default value be valid against the associated schema.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.3
     */
    default?: JSONSchema6Type | undefined;

    /**
     * Array of examples with no validation effect the value of "default" is usable as an example without repeating it under this keyword
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.4
     */
    examples?: JSONSchema6Type[] | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-8
     */
    format?: string | undefined;
}

// ==================================================================================================
// JSON Schema Draft 07
// ==================================================================================================
// https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
// --------------------------------------------------------------------------------------------------

/**
 * Primitive type
 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
 */
export type JSONSchema7TypeName =
    | "string" //
    | "number"
    | "integer"
    | "boolean"
    | "object"
    | "array"
    | "null";

/**
 * Primitive type
 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
 */
export type JSONSchema7Type =
    | string //
    | number
    | boolean
    | JSONSchema7Object
    | JSONSchema7Array
    | null;

// Workaround for infinite type recursion
export interface JSONSchema7Object {
    [key: string]: JSONSchema7Type;
}

// Workaround for infinite type recursion
// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
export interface JSONSchema7Array extends Array<JSONSchema7Type> {}

/**
 * Meta schema
 *
 * Recommended values:
 * - 'http://json-schema.org/schema#'
 * - 'http://json-schema.org/hyper-schema#'
 * - 'http://json-schema.org/draft-07/schema#'
 * - 'http://json-schema.org/draft-07/hyper-schema#'
 *
 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
 */
export type JSONSchema7Version = string;

/**
 * JSON Schema v7
 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
 */
export type JSONSchema7Definition = JSONSchema7 | boolean;
export interface JSONSchema7 {
    $id?: string | undefined;
    $ref?: string | undefined;
    $schema?: JSONSchema7Version | undefined;
    $comment?: string | undefined;

    /**
     * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-00#section-8.2.4
     * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#appendix-A
     */
    $defs?: {
        [key: string]: JSONSchema7Definition;
    } | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1
     */
    type?: JSONSchema7TypeName | JSONSchema7TypeName[] | undefined;
    enum?: JSONSchema7Type[] | undefined;
    const?: JSONSchema7Type | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.2
     */
    multipleOf?: number | undefined;
    maximum?: number | undefined;
    exclusiveMaximum?: number | undefined;
    minimum?: number | undefined;
    exclusiveMinimum?: number | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.3
     */
    maxLength?: number | undefined;
    minLength?: number | undefined;
    pattern?: string | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.4
     */
    items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
    additionalItems?: JSONSchema7Definition | undefined;
    maxItems?: number | undefined;
    minItems?: number | undefined;
    uniqueItems?: boolean | undefined;
    contains?: JSONSchema7Definition | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.5
     */
    maxProperties?: number | undefined;
    minProperties?: number | undefined;
    required?: string[] | undefined;
    properties?: {
        [key: string]: JSONSchema7Definition;
    } | undefined;
    patternProperties?: {
        [key: string]: JSONSchema7Definition;
    } | undefined;
    additionalProperties?: JSONSchema7Definition | undefined;
    dependencies?: {
        [key: string]: JSONSchema7Definition | string[];
    } | undefined;
    propertyNames?: JSONSchema7Definition | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.6
     */
    if?: JSONSchema7Definition | undefined;
    then?: JSONSchema7Definition | undefined;
    else?: JSONSchema7Definition | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.7
     */
    allOf?: JSONSchema7Definition[] | undefined;
    anyOf?: JSONSchema7Definition[] | undefined;
    oneOf?: JSONSchema7Definition[] | undefined;
    not?: JSONSchema7Definition | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-7
     */
    format?: string | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-8
     */
    contentMediaType?: string | undefined;
    contentEncoding?: string | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-9
     */
    definitions?: {
        [key: string]: JSONSchema7Definition;
    } | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
     */
    title?: string | undefined;
    description?: string | undefined;
    default?: JSONSchema7Type | undefined;
    readOnly?: boolean | undefined;
    writeOnly?: boolean | undefined;
    examples?: JSONSchema7Type | undefined;
}

export interface ValidationResult {
    valid: boolean;
    errors: ValidationError[];
}

export interface ValidationError {
    property: string;
    message: string;
}

/**
 * To use the validator call JSONSchema.validate with an instance object and an optional schema object.
 * If a schema is provided, it will be used to validate. If the instance object refers to a schema (self-validating),
 * that schema will be used to validate and the schema parameter is not necessary (if both exist,
 * both validations will occur).
 */
export function validate(instance: {}, schema: JSONSchema4 | JSONSchema6 | JSONSchema7): ValidationResult;

/**
 * The checkPropertyChange method will check to see if an value can legally be in property with the given schema
 * This is slightly different than the validate method in that it will fail if the schema is readonly and it will
 * not check for self-validation, it is assumed that the passed in value is already internally valid.
 */
export function checkPropertyChange(
    value: any,
    schema: JSONSchema4 | JSONSchema6 | JSONSchema7,
    property: string,
): ValidationResult;

/**
 * This checks to ensure that the result is valid and will throw an appropriate error message if it is not.
 */
export function mustBeValid(result: ValidationResult): void;


@types/json-schema

description: TypeScript definitions for json-schema

license: MIT

Boris Cherny

githubUsername: bcherny

Lucian Buzzo

githubUsername: lucianbuzzo

Roland Groza

githubUsername: rolandjitsu

Jason Kwok

githubUsername: JasonHK

type: git

directory: types/json-schema

license: mit


code:
# Installation
> `npm install --save @types/lodash-es`

# Summary
This package contains type definitions for lodash-es (http://lodash.com/).

# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/lodash-es.

### Additional Details
 * Last updated: Tue, 21 Nov 2023 16:07:37 GMT
 * Dependencies: [@types/lodash](https://npmjs.com/package/@types/lodash)

# Credits
These definitions were written by [Stephen Lautier](https://github.com/stephenlautier), and [e-cloud](https://github.com/e-cloud).


code:
import { add } from "lodash";
export default add;


code:
import { after } from "lodash";
export default after;


code:
import { default as chunk } from "./chunk";
import { default as compact } from "./compact";
import { default as concat } from "./concat";
import { default as difference } from "./difference";
import { default as differenceBy } from "./differenceBy";
import { default as differenceWith } from "./differenceWith";
import { default as drop } from "./drop";
import { default as dropRight } from "./dropRight";
import { default as dropRightWhile } from "./dropRightWhile";
import { default as dropWhile } from "./dropWhile";
import { default as fill } from "./fill";
import { default as findIndex } from "./findIndex";
import { default as findLastIndex } from "./findLastIndex";
import { default as first } from "./first";
import { default as flatten } from "./flatten";
import { default as flattenDeep } from "./flattenDeep";
import { default as flattenDepth } from "./flattenDepth";
import { default as fromPairs } from "./fromPairs";
import { default as head } from "./head";
import { default as indexOf } from "./indexOf";
import { default as initial } from "./initial";
import { default as intersection } from "./intersection";
import { default as intersectionBy } from "./intersectionBy";
import { default as intersectionWith } from "./intersectionWith";
import { default as join } from "./join";
import { default as last } from "./last";
import { default as lastIndexOf } from "./lastIndexOf";
import { default as nth } from "./nth";
import { default as pull } from "./pull";
import { default as pullAll } from "./pullAll";
import { default as pullAllBy } from "./pullAllBy";
import { default as pullAllWith } from "./pullAllWith";
import { default as pullAt } from "./pullAt";
import { default as remove } from "./remove";
import { default as reverse } from "./reverse";
import { default as slice } from "./slice";
import { default as sortedIndex } from "./sortedIndex";
import { default as sortedIndexBy } from "./sortedIndexBy";
import { default as sortedIndexOf } from "./sortedIndexOf";
import { default as sortedLastIndex } from "./sortedLastIndex";
import { default as sortedLastIndexBy } from "./sortedLastIndexBy";
import { default as sortedLastIndexOf } from "./sortedLastIndexOf";
import { default as sortedUniq } from "./sortedUniq";
import { default as sortedUniqBy } from "./sortedUniqBy";
import { default as tail } from "./tail";
import { default as take } from "./take";
import { default as takeRight } from "./takeRight";
import { default as takeRightWhile } from "./takeRightWhile";
import { default as takeWhile } from "./takeWhile";
import { default as union } from "./union";
import { default as unionBy } from "./unionBy";
import { default as unionWith } from "./unionWith";
import { default as uniq } from "./uniq";
import { default as uniqBy } from "./uniqBy";
import { default as uniqWith } from "./uniqWith";
import { default as unzip } from "./unzip";
import { default as unzipWith } from "./unzipWith";
import { default as without } from "./without";
import { default as xor } from "./xor";
import { default as xorBy } from "./xorBy";
import { default as xorWith } from "./xorWith";
import { default as zip } from "./zip";
import { default as zipObject } from "./zipObject";
import { default as zipObjectDeep } from "./zipObjectDeep";
import { default as zipWith } from "./zipWith";

export { default } from "./array.default";


code:
import chunk from "./chunk";
import compact from "./compact";
import concat from "./concat";
import difference from "./difference";
import differenceBy from "./differenceBy";
import differenceWith from "./differenceWith";
import drop from "./drop";
import dropRight from "./dropRight";
import dropRightWhile from "./dropRightWhile";
import dropWhile from "./dropWhile";
import fill from "./fill";
import findIndex from "./findIndex";
import findLastIndex from "./findLastIndex";
import first from "./first";
import flatten from "./flatten";
import flattenDeep from "./flattenDeep";
import flattenDepth from "./flattenDepth";
import fromPairs from "./fromPairs";
import head from "./head";
import indexOf from "./indexOf";
import initial from "./initial";
import intersection from "./intersection";
import intersectionBy from "./intersectionBy";
import intersectionWith from "./intersectionWith";
import join from "./join";
import last from "./last";
import lastIndexOf from "./lastIndexOf";
import nth from "./nth";
import pull from "./pull";
import pullAll from "./pullAll";
import pullAllBy from "./pullAllBy";
import pullAllWith from "./pullAllWith";
import pullAt from "./pullAt";
import remove from "./remove";
import reverse from "./reverse";
import slice from "./slice";
import sortedIndex from "./sortedIndex";
import sortedIndexBy from "./sortedIndexBy";
import sortedIndexOf from "./sortedIndexOf";
import sortedLastIndex from "./sortedLastIndex";
import sortedLastIndexBy from "./sortedLastIndexBy";
import sortedLastIndexOf from "./sortedLastIndexOf";
import sortedUniq from "./sortedUniq";
import sortedUniqBy from "./sortedUniqBy";
import tail from "./tail";
import take from "./take";
import takeRight from "./takeRight";
import takeRightWhile from "./takeRightWhile";
import takeWhile from "./takeWhile";
import union from "./union";
import unionBy from "./unionBy";
import unionWith from "./unionWith";
import uniq from "./uniq";
import uniqBy from "./uniqBy";
import uniqWith from "./uniqWith";
import unzip from "./unzip";
import unzipWith from "./unzipWith";
import without from "./without";
import xor from "./xor";
import xorBy from "./xorBy";
import xorWith from "./xorWith";
import zip from "./zip";
import zipObject from "./zipObject";
import zipObjectDeep from "./zipObjectDeep";
import zipWith from "./zipWith";

declare const defaultExport: {
    chunk: typeof chunk;
    compact: typeof compact;
    concat: typeof concat;
    difference: typeof difference;
    differenceBy: typeof differenceBy;
    differenceWith: typeof differenceWith;
    drop: typeof drop;
    dropRight: typeof dropRight;
    dropRightWhile: typeof dropRightWhile;
    dropWhile: typeof dropWhile;
    fill: typeof fill;
    findIndex: typeof findIndex;
    findLastIndex: typeof findLastIndex;
    first: typeof first;
    flatten: typeof flatten;
    flattenDeep: typeof flattenDeep;
    flattenDepth: typeof flattenDepth;
    fromPairs: typeof fromPairs;
    head: typeof head;
    indexOf: typeof indexOf;
    initial: typeof initial;
    intersection: typeof intersection;
    intersectionBy: typeof intersectionBy;
    intersectionWith: typeof intersectionWith;
    join: typeof join;
    last: typeof last;
    lastIndexOf: typeof lastIndexOf;
    nth: typeof nth;
    pull: typeof pull;
    pullAll: typeof pullAll;
    pullAllBy: typeof pullAllBy;
    pullAllWith: typeof pullAllWith;
    pullAt: typeof pullAt;
    remove: typeof remove;
    reverse: typeof reverse;
    slice: typeof slice;
    sortedIndex: typeof sortedIndex;
    sortedIndexBy: typeof sortedIndexBy;
    sortedIndexOf: typeof sortedIndexOf;
    sortedLastIndex: typeof sortedLastIndex;
    sortedLastIndexBy: typeof sortedLastIndexBy;
    sortedLastIndexOf: typeof sortedLastIndexOf;
    sortedUniq: typeof sortedUniq;
    sortedUniqBy: typeof sortedUniqBy;
    tail: typeof tail;
    take: typeof take;
    takeRight: typeof takeRight;
    takeRightWhile: typeof takeRightWhile;
    takeWhile: typeof takeWhile;
    union: typeof union;
    unionBy: typeof unionBy;
    unionWith: typeof unionWith;
    uniq: typeof uniq;
    uniqBy: typeof uniqBy;
    uniqWith: typeof uniqWith;
    unzip: typeof unzip;
    unzipWith: typeof unzipWith;
    without: typeof without;
    xor: typeof xor;
    xorBy: typeof xorBy;
    xorWith: typeof xorWith;
    zip: typeof zip;
    zipObject: typeof zipObject;
    zipObjectDeep: typeof zipObjectDeep;
    zipWith: typeof zipWith;
};
export default defaultExport;


code:
import { ary } from "lodash";
export default ary;


code:
import { assign } from "lodash";
export default assign;


code:
import { assignIn } from "lodash";
export default assignIn;


code:
import { assignInWith } from "lodash";
export default assignInWith;


code:
import { assignWith } from "lodash";
export default assignWith;


code:
import { at } from "lodash";
export default at;


code:
import { attempt } from "lodash";
export default attempt;


code:
import { before } from "lodash";
export default before;


code:
import { bind } from "lodash";
export default bind;


code:
import { bindAll } from "lodash";
export default bindAll;


code:
import { bindKey } from "lodash";
export default bindKey;


code:
import { camelCase } from "lodash";
export default camelCase;


code:
import { capitalize } from "lodash";
export default capitalize;


code:
import { castArray } from "lodash";
export default castArray;


code:
import { ceil } from "lodash";
export default ceil;


code:
import { chain } from "lodash";
export default chain;


code:
import { chunk } from "lodash";
export default chunk;


code:
import { clamp } from "lodash";
export default clamp;


code:
import { clone } from "lodash";
export default clone;


code:
import { cloneDeep } from "lodash";
export default cloneDeep;


code:
import { cloneDeepWith } from "lodash";
export default cloneDeepWith;


code:
import { cloneWith } from "lodash";
export default cloneWith;


code:
import { default as countBy } from "./countBy";
import { default as each } from "./each";
import { default as eachRight } from "./eachRight";
import { default as every } from "./every";
import { default as filter } from "./filter";
import { default as find } from "./find";
import { default as findLast } from "./findLast";
import { default as flatMap } from "./flatMap";
import { default as flatMapDeep } from "./flatMapDeep";
import { default as flatMapDepth } from "./flatMapDepth";
import { default as forEach } from "./forEach";
import { default as forEachRight } from "./forEachRight";
import { default as groupBy } from "./groupBy";
import { default as includes } from "./includes";
import { default as invokeMap } from "./invokeMap";
import { default as keyBy } from "./keyBy";
import { default as map } from "./map";
import { default as orderBy } from "./orderBy";
import { default as partition } from "./partition";
import { default as reduce } from "./reduce";
import { default as reduceRight } from "./reduceRight";
import { default as reject } from "./reject";
import { default as sample } from "./sample";
import { default as sampleSize } from "./sampleSize";
import { default as shuffle } from "./shuffle";
import { default as size } from "./size";
import { default as some } from "./some";
import { default as sortBy } from "./sortBy";

export { default } from "./collection.default";


code:
import countBy from "./countBy";
import each from "./each";
import eachRight from "./eachRight";
import every from "./every";
import filter from "./filter";
import find from "./find";
import findLast from "./findLast";
import flatMap from "./flatMap";
import flatMapDeep from "./flatMapDeep";
import flatMapDepth from "./flatMapDepth";
import forEach from "./forEach";
import forEachRight from "./forEachRight";
import groupBy from "./groupBy";
import includes from "./includes";
import invokeMap from "./invokeMap";
import keyBy from "./keyBy";
import map from "./map";
import orderBy from "./orderBy";
import partition from "./partition";
import reduce from "./reduce";
import reduceRight from "./reduceRight";
import reject from "./reject";
import sample from "./sample";
import sampleSize from "./sampleSize";
import shuffle from "./shuffle";
import size from "./size";
import some from "./some";
import sortBy from "./sortBy";

declare const defaultExport: {
    countBy: typeof countBy;
    each: typeof each;
    eachRight: typeof eachRight;
    every: typeof every;
    filter: typeof filter;
    find: typeof find;
    findLast: typeof findLast;
    flatMap: typeof flatMap;
    flatMapDeep: typeof flatMapDeep;
    flatMapDepth: typeof flatMapDepth;
    forEach: typeof forEach;
    forEachRight: typeof forEachRight;
    groupBy: typeof groupBy;
    includes: typeof includes;
    invokeMap: typeof invokeMap;
    keyBy: typeof keyBy;
    map: typeof map;
    orderBy: typeof orderBy;
    partition: typeof partition;
    reduce: typeof reduce;
    reduceRight: typeof reduceRight;
    reject: typeof reject;
    sample: typeof sample;
    sampleSize: typeof sampleSize;
    shuffle: typeof shuffle;
    size: typeof size;
    some: typeof some;
    sortBy: typeof sortBy;
};
export default defaultExport;


code:
import { compact } from "lodash";
export default compact;


code:
import { concat } from "lodash";
export default concat;


code:
import { cond } from "lodash";
export default cond;


code:
import { conforms } from "lodash";
export default conforms;


code:
import { conformsTo } from "lodash";
export default conformsTo;


code:
import { constant } from "lodash";
export default constant;


code:
import { countBy } from "lodash";
export default countBy;


code:
import { create } from "lodash";
export default create;


code:
import { curry } from "lodash";
export default curry;


code:
import { curryRight } from "lodash";
export default curryRight;


code:
import { default as now } from "./now";

export { default } from "./date.default";


code:
import now from "./now";

declare const defaultExport: {
    now: typeof now;
};
export default defaultExport;


code:
import { debounce, DebouncedFunc, DebounceSettings } from "lodash";

export { DebouncedFunc, DebounceSettings };
export default debounce;


code:
import { deburr } from "lodash";
export default deburr;


code:
import { defaultTo } from "lodash";
export default defaultTo;


code:
import { defaults } from "lodash";
export default defaults;


code:
import { defaultsDeep } from "lodash";
export default defaultsDeep;


code:
import { defer } from "lodash";
export default defer;


code:
import { delay } from "lodash";
export default delay;


code:
import { difference } from "lodash";
export default difference;


code:
import { differenceBy } from "lodash";
export default differenceBy;


code:
import { differenceWith } from "lodash";
export default differenceWith;


code:
import { divide } from "lodash";
export default divide;


code:
import { drop } from "lodash";
export default drop;


code:
import { dropRight } from "lodash";
export default dropRight;


code:
import { dropRightWhile } from "lodash";
export default dropRightWhile;


code:
import { dropWhile } from "lodash";
export default dropWhile;


code:
import { each } from "lodash";
export default each;


code:
import { eachRight } from "lodash";
export default eachRight;


code:
import { endsWith } from "lodash";
export default endsWith;


code:
import { entries } from "lodash";
export default entries;


code:
import { entriesIn } from "lodash";
export default entriesIn;


code:
import { eq } from "lodash";
export default eq;


code:
import { escape } from "lodash";
export default escape;


code:
import { escapeRegExp } from "lodash";
export default escapeRegExp;


code:
import { every } from "lodash";
export default every;


code:
import { extend } from "lodash";
export default extend;


code:
import { extendWith } from "lodash";
export default extendWith;


code:
import { fill } from "lodash";
export default fill;


code:
import { filter } from "lodash";
export default filter;


code:
import { find } from "lodash";
export default find;


code:
import { findIndex } from "lodash";
export default findIndex;


code:
import { findKey } from "lodash";
export default findKey;


code:
import { findLast } from "lodash";
export default findLast;


code:
import { findLastIndex } from "lodash";
export default findLastIndex;


code:
import { findLastKey } from "lodash";
export default findLastKey;


code:
import { first } from "lodash";
export default first;


code:
import { flatMap } from "lodash";
export default flatMap;


code:
import { flatMapDeep } from "lodash";
export default flatMapDeep;


code:
import { flatMapDepth } from "lodash";
export default flatMapDepth;


code:
import { flatten } from "lodash";
export default flatten;


code:
import { flattenDeep } from "lodash";
export default flattenDeep;


code:
import { flattenDepth } from "lodash";
export default flattenDepth;


code:
import { flip } from "lodash";
export default flip;


code:
import { floor } from "lodash";
export default floor;


code:
import { flow } from "lodash";
export default flow;


code:
import { flowRight } from "lodash";
export default flowRight;


code:
import { forEach } from "lodash";
export default forEach;


code:
import { forEachRight } from "lodash";
export default forEachRight;


code:
import { forIn } from "lodash";
export default forIn;


code:
import { forInRight } from "lodash";
export default forInRight;


code:
import { forOwn } from "lodash";
export default forOwn;


code:
import { forOwnRight } from "lodash";
export default forOwnRight;


code:
import { fromPairs } from "lodash";
export default fromPairs;


code:
import { default as after } from "./after";
import { default as ary } from "./ary";
import { default as before } from "./before";
import { default as bind } from "./bind";
import { default as bindKey } from "./bindKey";
import { default as curry } from "./curry";
import { default as curryRight } from "./curryRight";
import { default as debounce } from "./debounce";
import { default as defer } from "./defer";
import { default as delay } from "./delay";
import { default as flip } from "./flip";
import { default as memoize } from "./memoize";
import { default as negate } from "./negate";
import { default as once } from "./once";
import { default as overArgs } from "./overArgs";
import { default as partial } from "./partial";
import { default as partialRight } from "./partialRight";
import { default as rearg } from "./rearg";
import { default as rest } from "./rest";
import { default as spread } from "./spread";
import { default as throttle } from "./throttle";
import { default as unary } from "./unary";
import { default as wrap } from "./wrap";

export { default } from "./function.default";


code:
import after from "./after";
import ary from "./ary";
import before from "./before";
import bind from "./bind";
import bindKey from "./bindKey";
import curry from "./curry";
import curryRight from "./curryRight";
import debounce from "./debounce";
import defer from "./defer";
import delay from "./delay";
import flip from "./flip";
import memoize from "./memoize";
import negate from "./negate";
import once from "./once";
import overArgs from "./overArgs";
import partial from "./partial";
import partialRight from "./partialRight";
import rearg from "./rearg";
import rest from "./rest";
import spread from "./spread";
import throttle from "./throttle";
import unary from "./unary";
import wrap from "./wrap";

declare const defaultExport: {
    after: typeof after;
    ary: typeof ary;
    before: typeof before;
    bind: typeof bind;
    bindKey: typeof bindKey;
    curry: typeof curry;
    curryRight: typeof curryRight;
    debounce: typeof debounce;
    defer: typeof defer;
    delay: typeof delay;
    flip: typeof flip;
    memoize: typeof memoize;
    negate: typeof negate;
    once: typeof once;
    overArgs: typeof overArgs;
    partial: typeof partial;
    partialRight: typeof partialRight;
    rearg: typeof rearg;
    rest: typeof rest;
    spread: typeof spread;
    throttle: typeof throttle;
    unary: typeof unary;
    wrap: typeof wrap;
};
export default defaultExport;


code:
import { functions } from "lodash";
export default functions;


code:
import { functionsIn } from "lodash";
export default functionsIn;


code:
import { get } from "lodash";
export default get;


code:
import { groupBy } from "lodash";
export default groupBy;


code:
import { gt } from "lodash";
export default gt;


code:
import { gte } from "lodash";
export default gte;


code:
import { has } from "lodash";
export default has;


code:
import { hasIn } from "lodash";
export default hasIn;


code:
import { head } from "lodash";
export default head;


code:
import { identity } from "lodash";
export default identity;


code:
import { inRange } from "lodash";
export default inRange;


code:
import { includes } from "lodash";
export default includes;


code:
export { default as add } from "./add.js";
export { default as after } from "./after.js";
export { default as ary } from "./ary.js";
export { default as assign } from "./assign.js";
export { default as assignIn } from "./assignIn.js";
export { default as assignInWith } from "./assignInWith.js";
export { default as assignWith } from "./assignWith.js";
export { default as at } from "./at.js";
export { default as attempt } from "./attempt.js";
export { default as before } from "./before.js";
export { default as bind } from "./bind.js";
export { default as bindAll } from "./bindAll.js";
export { default as bindKey } from "./bindKey.js";
export { default as camelCase } from "./camelCase.js";
export { default as capitalize } from "./capitalize.js";
export { default as castArray } from "./castArray.js";
export { default as ceil } from "./ceil.js";
export { default as chain } from "./chain.js";
export { default as chunk } from "./chunk.js";
export { default as clamp } from "./clamp.js";
export { default as clone } from "./clone.js";
export { default as cloneDeep } from "./cloneDeep.js";
export { default as cloneDeepWith } from "./cloneDeepWith.js";
export { default as cloneWith } from "./cloneWith.js";
export { default as compact } from "./compact.js";
export { default as concat } from "./concat.js";
export { default as cond } from "./cond.js";
export { default as conforms } from "./conforms.js";
export { default as conformsTo } from "./conformsTo.js";
export { default as constant } from "./constant.js";
export { default as countBy } from "./countBy.js";
export { default as create } from "./create.js";
export { default as curry } from "./curry.js";
export { default as curryRight } from "./curryRight.js";
export { DebouncedFunc, DebounceSettings, default as debounce } from "./debounce.js";
export { default as deburr } from "./deburr.js";
export { default as defaults } from "./defaults.js";
export { default as defaultsDeep } from "./defaultsDeep.js";
export { default as defaultTo } from "./defaultTo.js";
export { default as defer } from "./defer.js";
export { default as delay } from "./delay.js";
export { default as difference } from "./difference.js";
export { default as differenceBy } from "./differenceBy.js";
export { default as differenceWith } from "./differenceWith.js";
export { default as divide } from "./divide.js";
export { default as drop } from "./drop.js";
export { default as dropRight } from "./dropRight.js";
export { default as dropRightWhile } from "./dropRightWhile.js";
export { default as dropWhile } from "./dropWhile.js";
export { default as each } from "./each.js";
export { default as eachRight } from "./eachRight.js";
export { default as endsWith } from "./endsWith.js";
export { default as entries } from "./entries.js";
export { default as entriesIn } from "./entriesIn.js";
export { default as eq } from "./eq.js";
export { default as escape } from "./escape.js";
export { default as escapeRegExp } from "./escapeRegExp.js";
export { default as every } from "./every.js";
export { default as extend } from "./extend.js";
export { default as extendWith } from "./extendWith.js";
export { default as fill } from "./fill.js";
export { default as filter } from "./filter.js";
export { default as find } from "./find.js";
export { default as findIndex } from "./findIndex.js";
export { default as findKey } from "./findKey.js";
export { default as findLast } from "./findLast.js";
export { default as findLastIndex } from "./findLastIndex.js";
export { default as findLastKey } from "./findLastKey.js";
export { default as first } from "./first.js";
export { default as flatMap } from "./flatMap.js";
export { default as flatMapDeep } from "./flatMapDeep.js";
export { default as flatMapDepth } from "./flatMapDepth.js";
export { default as flatten } from "./flatten.js";
export { default as flattenDeep } from "./flattenDeep.js";
export { default as flattenDepth } from "./flattenDepth.js";
export { default as flip } from "./flip.js";
export { default as floor } from "./floor.js";
export { default as flow } from "./flow.js";
export { default as flowRight } from "./flowRight.js";
export { default as forEach } from "./forEach.js";
export { default as forEachRight } from "./forEachRight.js";
export { default as forIn } from "./forIn.js";
export { default as forInRight } from "./forInRight.js";
export { default as forOwn } from "./forOwn.js";
export { default as forOwnRight } from "./forOwnRight.js";
export { default as fromPairs } from "./fromPairs.js";
export { default as functions } from "./functions.js";
export { default as functionsIn } from "./functionsIn.js";
export { default as get } from "./get.js";
export { default as groupBy } from "./groupBy.js";
export { default as gt } from "./gt.js";
export { default as gte } from "./gte.js";
export { default as has } from "./has.js";
export { default as hasIn } from "./hasIn.js";
export { default as head } from "./head.js";
export { default as identity } from "./identity.js";
export { default as includes } from "./includes.js";
export { default as indexOf } from "./indexOf.js";
export { default as initial } from "./initial.js";
export { default as inRange } from "./inRange.js";
export { default as intersection } from "./intersection.js";
export { default as intersectionBy } from "./intersectionBy.js";
export { default as intersectionWith } from "./intersectionWith.js";
export { default as invert } from "./invert.js";
export { default as invertBy } from "./invertBy.js";
export { default as invoke } from "./invoke.js";
export { default as invokeMap } from "./invokeMap.js";
export { default as isArguments } from "./isArguments.js";
export { default as isArray } from "./isArray.js";
export { default as isArrayBuffer } from "./isArrayBuffer.js";
export { default as isArrayLike } from "./isArrayLike.js";
export { default as isArrayLikeObject } from "./isArrayLikeObject.js";
export { default as isBoolean } from "./isBoolean.js";
export { default as isBuffer } from "./isBuffer.js";
export { default as isDate } from "./isDate.js";
export { default as isElement } from "./isElement.js";
export { default as isEmpty } from "./isEmpty.js";
export { default as isEqual } from "./isEqual.js";
export { default as isEqualWith } from "./isEqualWith.js";
export { default as isError } from "./isError.js";
export { default as isFinite } from "./isFinite.js";
export { default as isFunction } from "./isFunction.js";
export { default as isInteger } from "./isInteger.js";
export { default as isLength } from "./isLength.js";
export { default as isMap } from "./isMap.js";
export { default as isMatch } from "./isMatch.js";
export { default as isMatchWith } from "./isMatchWith.js";
export { default as isNaN } from "./isNaN.js";
export { default as isNative } from "./isNative.js";
export { default as isNil } from "./isNil.js";
export { default as isNull } from "./isNull.js";
export { default as isNumber } from "./isNumber.js";
export { default as isObject } from "./isObject.js";
export { default as isObjectLike } from "./isObjectLike.js";
export { default as isPlainObject } from "./isPlainObject.js";
export { default as isRegExp } from "./isRegExp.js";
export { default as isSafeInteger } from "./isSafeInteger.js";
export { default as isSet } from "./isSet.js";
export { default as isString } from "./isString.js";
export { default as isSymbol } from "./isSymbol.js";
export { default as isTypedArray } from "./isTypedArray.js";
export { default as isUndefined } from "./isUndefined.js";
export { default as isWeakMap } from "./isWeakMap.js";
export { default as isWeakSet } from "./isWeakSet.js";
export { default as iteratee } from "./iteratee.js";
export { default as join } from "./join.js";
export { default as kebabCase } from "./kebabCase.js";
export { default as keyBy } from "./keyBy.js";
export { default as keys } from "./keys.js";
export { default as keysIn } from "./keysIn.js";
export { default as last } from "./last.js";
export { default as lastIndexOf } from "./lastIndexOf.js";
export { default as lowerCase } from "./lowerCase.js";
export { default as lowerFirst } from "./lowerFirst.js";
export { default as lt } from "./lt.js";
export { default as lte } from "./lte.js";
export { default as map } from "./map.js";
export { default as mapKeys } from "./mapKeys.js";
export { default as mapValues } from "./mapValues.js";
export { default as matches } from "./matches.js";
export { default as matchesProperty } from "./matchesProperty.js";
export { default as max } from "./max.js";
export { default as maxBy } from "./maxBy.js";
export { default as mean } from "./mean.js";
export { default as meanBy } from "./meanBy.js";
export { default as memoize } from "./memoize.js";
export { default as merge } from "./merge.js";
export { default as mergeWith } from "./mergeWith.js";
export { default as method } from "./method.js";
export { default as methodOf } from "./methodOf.js";
export { default as min } from "./min.js";
export { default as minBy } from "./minBy.js";
export { default as mixin } from "./mixin.js";
export { default as multiply } from "./multiply.js";
export { default as negate } from "./negate.js";
export { default as noop } from "./noop.js";
export { default as now } from "./now.js";
export { default as nth } from "./nth.js";
export { default as nthArg } from "./nthArg.js";
export { default as omit } from "./omit.js";
export { default as omitBy } from "./omitBy.js";
export { default as once } from "./once.js";
export { default as orderBy } from "./orderBy.js";
export { default as over } from "./over.js";
export { default as overArgs } from "./overArgs.js";
export { default as overEvery } from "./overEvery.js";
export { default as overSome } from "./overSome.js";
export { default as pad } from "./pad.js";
export { default as padEnd } from "./padEnd.js";
export { default as padStart } from "./padStart.js";
export { default as parseInt } from "./parseInt.js";
export { default as partial } from "./partial.js";
export { default as partialRight } from "./partialRight.js";
export { default as partition } from "./partition.js";
export { default as pick } from "./pick.js";
export { default as pickBy } from "./pickBy.js";
export { default as property, PropertyPath } from "./property.js";
export { default as propertyOf } from "./propertyOf.js";
export { default as pull } from "./pull.js";
export { default as pullAll } from "./pullAll.js";
export { default as pullAllBy } from "./pullAllBy.js";
export { default as pullAllWith } from "./pullAllWith.js";
export { default as pullAt } from "./pullAt.js";
export { default as random } from "./random.js";
export { default as range } from "./range.js";
export { default as rangeRight } from "./rangeRight.js";
export { default as rearg } from "./rearg.js";
export { default as reduce } from "./reduce.js";
export { default as reduceRight } from "./reduceRight.js";
export { default as reject } from "./reject.js";
export { default as remove } from "./remove.js";
export { default as repeat } from "./repeat.js";
export { default as replace } from "./replace.js";
export { default as rest } from "./rest.js";
export { default as result } from "./result.js";
export { default as reverse } from "./reverse.js";
export { default as round } from "./round.js";
export { default as sample } from "./sample.js";
export { default as sampleSize } from "./sampleSize.js";
export { default as set } from "./set.js";
export { default as setWith } from "./setWith.js";
export { default as shuffle } from "./shuffle.js";
export { default as size } from "./size.js";
export { default as slice } from "./slice.js";
export { default as snakeCase } from "./snakeCase.js";
export { default as some } from "./some.js";
export { default as sortBy } from "./sortBy.js";
export { default as sortedIndex } from "./sortedIndex.js";
export { default as sortedIndexBy } from "./sortedIndexBy.js";
export { default as sortedIndexOf } from "./sortedIndexOf.js";
export { default as sortedLastIndex } from "./sortedLastIndex.js";
export { default as sortedLastIndexBy } from "./sortedLastIndexBy.js";
export { default as sortedLastIndexOf } from "./sortedLastIndexOf.js";
export { default as sortedUniq } from "./sortedUniq.js";
export { default as sortedUniqBy } from "./sortedUniqBy.js";
export { default as split } from "./split.js";
export { default as spread } from "./spread.js";
export { default as startCase } from "./startCase.js";
export { default as startsWith } from "./startsWith.js";
export { default as stubArray } from "./stubArray.js";
export { default as stubFalse } from "./stubFalse.js";
export { default as stubObject } from "./stubObject.js";
export { default as stubString } from "./stubString.js";
export { default as stubTrue } from "./stubTrue.js";
export { default as subtract } from "./subtract.js";
export { default as sum } from "./sum.js";
export { default as sumBy } from "./sumBy.js";
export { default as tail } from "./tail.js";
export { default as take } from "./take.js";
export { default as takeRight } from "./takeRight.js";
export { default as takeRightWhile } from "./takeRightWhile.js";
export { default as takeWhile } from "./takeWhile.js";
export { default as tap } from "./tap.js";
export { default as template } from "./template.js";
export { default as templateSettings } from "./templateSettings.js";
export { default as throttle, ThrottleSettings } from "./throttle.js";
export { default as thru } from "./thru.js";
export { default as times } from "./times.js";
export { default as toArray } from "./toArray.js";
export { default as toFinite } from "./toFinite.js";
export { default as toInteger } from "./toInteger.js";
export { default as toLength } from "./toLength.js";
export { default as toLower } from "./toLower.js";
export { default as toNumber } from "./toNumber.js";
export { default as toPairs } from "./toPairs.js";
export { default as toPairsIn } from "./toPairsIn.js";
export { default as toPath } from "./toPath.js";
export { default as toPlainObject } from "./toPlainObject.js";
export { default as toSafeInteger } from "./toSafeInteger.js";
export { default as toString } from "./toString.js";
export { default as toUpper } from "./toUpper.js";
export { default as transform } from "./transform.js";
export { default as trim } from "./trim.js";
export { default as trimEnd } from "./trimEnd.js";
export { default as trimStart } from "./trimStart.js";
export { default as truncate } from "./truncate.js";
export { default as unary } from "./unary.js";
export { default as unescape } from "./unescape.js";
export { default as union } from "./union.js";
export { default as unionBy } from "./unionBy.js";
export { default as unionWith } from "./unionWith.js";
export { default as uniq } from "./uniq.js";
export { default as uniqBy } from "./uniqBy.js";
export { default as uniqueId } from "./uniqueId.js";
export { default as uniqWith } from "./uniqWith.js";
export { default as unset } from "./unset.js";
export { default as unzip } from "./unzip.js";
export { default as unzipWith } from "./unzipWith.js";
export { default as update } from "./update.js";
export { default as updateWith } from "./updateWith.js";
export { default as upperCase } from "./upperCase.js";
export { default as upperFirst } from "./upperFirst.js";
export { default as values } from "./values.js";
export { default as valuesIn } from "./valuesIn.js";
export { default as without } from "./without.js";
export { default as words } from "./words.js";
export { default as wrap } from "./wrap.js";
export { default as xor } from "./xor.js";
export { default as xorBy } from "./xorBy.js";
export { default as xorWith } from "./xorWith.js";
export { default as zip } from "./zip.js";
export { default as zipObject } from "./zipObject.js";
export { default as zipObjectDeep } from "./zipObjectDeep.js";
export { default as zipWith } from "./zipWith.js";


code:
import { indexOf } from "lodash";
export default indexOf;


code:
import { initial } from "lodash";
export default initial;


code:
import { intersection } from "lodash";
export default intersection;


code:
import { intersectionBy } from "lodash";
export default intersectionBy;


code:
import { intersectionWith } from "lodash";
export default intersectionWith;


code:
import { invert } from "lodash";
export default invert;


code:
import { invertBy } from "lodash";
export default invertBy;


code:
import { invoke } from "lodash";
export default invoke;


code:
import { invokeMap } from "lodash";
export default invokeMap;


code:
import { isArguments } from "lodash";
export default isArguments;


code:
import { isArray } from "lodash";
export default isArray;


code:
import { isArrayBuffer } from "lodash";
export default isArrayBuffer;


code:
import { isArrayLike } from "lodash";
export default isArrayLike;


code:
import { isArrayLikeObject } from "lodash";
export default isArrayLikeObject;


code:
import { isBoolean } from "lodash";
export default isBoolean;


code:
import { isBuffer } from "lodash";
export default isBuffer;


code:
import { isDate } from "lodash";
export default isDate;


code:
import { isElement } from "lodash";
export default isElement;


code:
import { isEmpty } from "lodash";
export default isEmpty;


code:
import { isEqual } from "lodash";
export default isEqual;


code:
import { isEqualWith } from "lodash";
export default isEqualWith;


code:
import { isError } from "lodash";
export default isError;


code:
import { isFinite } from "lodash";
export default isFinite;


code:
import { isFunction } from "lodash";
export default isFunction;


code:
import { isInteger } from "lodash";
export default isInteger;


code:
import { isLength } from "lodash";
export default isLength;


code:
import { isMap } from "lodash";
export default isMap;


code:
import { isMatch } from "lodash";
export default isMatch;


code:
import { isMatchWith } from "lodash";
export default isMatchWith;


code:
import { isNaN } from "lodash";
export default isNaN;


code:
import { isNative } from "lodash";
export default isNative;


code:
import { isNil } from "lodash";
export default isNil;


code:
import { isNull } from "lodash";
export default isNull;


code:
import { isNumber } from "lodash";
export default isNumber;


code:
import { isObject } from "lodash";
export default isObject;


code:
import { isObjectLike } from "lodash";
export default isObjectLike;


code:
import { isPlainObject } from "lodash";
export default isPlainObject;


code:
import { isRegExp } from "lodash";
export default isRegExp;


code:
import { isSafeInteger } from "lodash";
export default isSafeInteger;


code:
import { isSet } from "lodash";
export default isSet;


code:
import { isString } from "lodash";
export default isString;


code:
import { isSymbol } from "lodash";
export default isSymbol;


code:
import { isTypedArray } from "lodash";
export default isTypedArray;


code:
import { isUndefined } from "lodash";
export default isUndefined;


code:
import { isWeakMap } from "lodash";
export default isWeakMap;


code:
import { isWeakSet } from "lodash";
export default isWeakSet;


code:
import { iteratee } from "lodash";
export default iteratee;


code:
import { join } from "lodash";
export default join;


code:
import { kebabCase } from "lodash";
export default kebabCase;


code:
import { keyBy } from "lodash";
export default keyBy;


code:
import { keys } from "lodash";
export default keys;


code:
import { keysIn } from "lodash";
export default keysIn;


code:
import { default as castArray } from "./castArray";
import { default as clone } from "./clone";
import { default as cloneDeep } from "./cloneDeep";
import { default as cloneDeepWith } from "./cloneDeepWith";
import { default as cloneWith } from "./cloneWith";
import { default as conformsTo } from "./conformsTo";
import { default as eq } from "./eq";
import { default as gt } from "./gt";
import { default as gte } from "./gte";
import { default as isArguments } from "./isArguments";
import { default as isArray } from "./isArray";
import { default as isArrayBuffer } from "./isArrayBuffer";
import { default as isArrayLike } from "./isArrayLike";
import { default as isArrayLikeObject } from "./isArrayLikeObject";
import { default as isBoolean } from "./isBoolean";
import { default as isBuffer } from "./isBuffer";
import { default as isDate } from "./isDate";
import { default as isElement } from "./isElement";
import { default as isEmpty } from "./isEmpty";
import { default as isEqual } from "./isEqual";
import { default as isEqualWith } from "./isEqualWith";
import { default as isError } from "./isError";
import { default as isFinite } from "./isFinite";
import { default as isFunction } from "./isFunction";
import { default as isInteger } from "./isInteger";
import { default as isLength } from "./isLength";
import { default as isMap } from "./isMap";
import { default as isMatch } from "./isMatch";
import { default as isMatchWith } from "./isMatchWith";
import { default as isNaN } from "./isNaN";
import { default as isNative } from "./isNative";
import { default as isNil } from "./isNil";
import { default as isNull } from "./isNull";
import { default as isNumber } from "./isNumber";
import { default as isObject } from "./isObject";
import { default as isObjectLike } from "./isObjectLike";
import { default as isPlainObject } from "./isPlainObject";
import { default as isRegExp } from "./isRegExp";
import { default as isSafeInteger } from "./isSafeInteger";
import { default as isSet } from "./isSet";
import { default as isString } from "./isString";
import { default as isSymbol } from "./isSymbol";
import { default as isTypedArray } from "./isTypedArray";
import { default as isUndefined } from "./isUndefined";
import { default as isWeakMap } from "./isWeakMap";
import { default as isWeakSet } from "./isWeakSet";
import { default as lt } from "./lt";
import { default as lte } from "./lte";
import { default as toArray } from "./toArray";
import { default as toFinite } from "./toFinite";
import { default as toInteger } from "./toInteger";
import { default as toLength } from "./toLength";
import { default as toNumber } from "./toNumber";
import { default as toPlainObject } from "./toPlainObject";
import { default as toSafeInteger } from "./toSafeInteger";
import { default as toString } from "./toString";

export { default } from "./lang.default";


code:
import castArray from "./castArray";
import clone from "./clone";
import cloneDeep from "./cloneDeep";
import cloneDeepWith from "./cloneDeepWith";
import cloneWith from "./cloneWith";
import conformsTo from "./conformsTo";
import eq from "./eq";
import gt from "./gt";
import gte from "./gte";
import isArguments from "./isArguments";
import isArray from "./isArray";
import isArrayBuffer from "./isArrayBuffer";
import isArrayLike from "./isArrayLike";
import isArrayLikeObject from "./isArrayLikeObject";
import isBoolean from "./isBoolean";
import isBuffer from "./isBuffer";
import isDate from "./isDate";
import isElement from "./isElement";
import isEmpty from "./isEmpty";
import isEqual from "./isEqual";
import isEqualWith from "./isEqualWith";
import isError from "./isError";
import isFinite from "./isFinite";
import isFunction from "./isFunction";
import isInteger from "./isInteger";
import isLength from "./isLength";
import isMap from "./isMap";
import isMatch from "./isMatch";
import isMatchWith from "./isMatchWith";
import isNaN from "./isNaN";
import isNative from "./isNative";
import isNil from "./isNil";
import isNull from "./isNull";
import isNumber from "./isNumber";
import isObject from "./isObject";
import isObjectLike from "./isObjectLike";
import isPlainObject from "./isPlainObject";
import isRegExp from "./isRegExp";
import isSafeInteger from "./isSafeInteger";
import isSet from "./isSet";
import isString from "./isString";
import isSymbol from "./isSymbol";
import isTypedArray from "./isTypedArray";
import isUndefined from "./isUndefined";
import isWeakMap from "./isWeakMap";
import isWeakSet from "./isWeakSet";
import lt from "./lt";
import lte from "./lte";
import toArray from "./toArray";
import toFinite from "./toFinite";
import toInteger from "./toInteger";
import toLength from "./toLength";
import toNumber from "./toNumber";
import toPlainObject from "./toPlainObject";
import toSafeInteger from "./toSafeInteger";
import toString from "./toString";

declare const defaultExport: {
    castArray: typeof castArray;
    clone: typeof clone;
    cloneDeep: typeof cloneDeep;
    cloneDeepWith: typeof cloneDeepWith;
    cloneWith: typeof cloneWith;
    conformsTo: typeof conformsTo;
    eq: typeof eq;
    gt: typeof gt;
    gte: typeof gte;
    isArguments: typeof isArguments;
    isArray: typeof isArray;
    isArrayBuffer: typeof isArrayBuffer;
    isArrayLike: typeof isArrayLike;
    isArrayLikeObject: typeof isArrayLikeObject;
    isBoolean: typeof isBoolean;
    isBuffer: typeof isBuffer;
    isDate: typeof isDate;
    isElement: typeof isElement;
    isEmpty: typeof isEmpty;
    isEqual: typeof isEqual;
    isEqualWith: typeof isEqualWith;
    isError: typeof isError;
    isFinite: typeof isFinite;
    isFunction: typeof isFunction;
    isInteger: typeof isInteger;
    isLength: typeof isLength;
    isMap: typeof isMap;
    isMatch: typeof isMatch;
    isMatchWith: typeof isMatchWith;
    isNaN: typeof isNaN;
    isNative: typeof isNative;
    isNil: typeof isNil;
    isNull: typeof isNull;
    isNumber: typeof isNumber;
    isObject: typeof isObject;
    isObjectLike: typeof isObjectLike;
    isPlainObject: typeof isPlainObject;
    isRegExp: typeof isRegExp;
    isSafeInteger: typeof isSafeInteger;
    isSet: typeof isSet;
    isString: typeof isString;
    isSymbol: typeof isSymbol;
    isTypedArray: typeof isTypedArray;
    isUndefined: typeof isUndefined;
    isWeakMap: typeof isWeakMap;
    isWeakSet: typeof isWeakSet;
    lt: typeof lt;
    lte: typeof lte;
    toArray: typeof toArray;
    toFinite: typeof toFinite;
    toInteger: typeof toInteger;
    toLength: typeof toLength;
    toNumber: typeof toNumber;
    toPlainObject: typeof toPlainObject;
    toSafeInteger: typeof toSafeInteger;
    toString: typeof toString;
};
export default defaultExport;


code:
import { last } from "lodash";
export default last;


code:
import { lastIndexOf } from "lodash";
export default lastIndexOf;


code:
import { lowerCase } from "lodash";
export default lowerCase;


code:
import { lowerFirst } from "lodash";
export default lowerFirst;


code:
import { lt } from "lodash";
export default lt;


code:
import { lte } from "lodash";
export default lte;


code:
import { map } from "lodash";
export default map;


code:
import { mapKeys } from "lodash";
export default mapKeys;


code:
import { mapValues } from "lodash";
export default mapValues;


code:
import { matches } from "lodash";
export default matches;


code:
import { matchesProperty } from "lodash";
export default matchesProperty;


code:
import { default as add } from "./add";
import { default as ceil } from "./ceil";
import { default as divide } from "./divide";
import { default as floor } from "./floor";
import { default as max } from "./max";
import { default as maxBy } from "./maxBy";
import { default as mean } from "./mean";
import { default as meanBy } from "./meanBy";
import { default as min } from "./min";
import { default as minBy } from "./minBy";
import { default as multiply } from "./multiply";
import { default as round } from "./round";
import { default as subtract } from "./subtract";
import { default as sum } from "./sum";
import { default as sumBy } from "./sumBy";

export { default } from "./math.default";


code:
import add from "./add";
import ceil from "./ceil";
import divide from "./divide";
import floor from "./floor";
import max from "./max";
import maxBy from "./maxBy";
import mean from "./mean";
import meanBy from "./meanBy";
import min from "./min";
import minBy from "./minBy";
import multiply from "./multiply";
import round from "./round";
import subtract from "./subtract";
import sum from "./sum";
import sumBy from "./sumBy";

declare const defaultExport: {
    add: typeof add;
    ceil: typeof ceil;
    divide: typeof divide;
    floor: typeof floor;
    max: typeof max;
    maxBy: typeof maxBy;
    mean: typeof mean;
    meanBy: typeof meanBy;
    min: typeof min;
    minBy: typeof minBy;
    multiply: typeof multiply;
    round: typeof round;
    subtract: typeof subtract;
    sum: typeof sum;
    sumBy: typeof sumBy;
};
export default defaultExport;


code:
import { max } from "lodash";
export default max;


code:
import { maxBy } from "lodash";
export default maxBy;


code:
import { mean } from "lodash";
export default mean;


code:
import { meanBy } from "lodash";
export default meanBy;


code:
import { memoize } from "lodash";
export default memoize;


code:
import { merge } from "lodash";
export default merge;


code:
import { mergeWith } from "lodash";
export default mergeWith;


code:
import { method } from "lodash";
export default method;


code:
import { methodOf } from "lodash";
export default methodOf;


code:
import { min } from "lodash";
export default min;


code:
import { minBy } from "lodash";
export default minBy;


code:
import { mixin } from "lodash";
export default mixin;


code:
import { multiply } from "lodash";
export default multiply;


code:
import { negate } from "lodash";
export default negate;


code:
import { noop } from "lodash";
export default noop;


code:
import { now } from "lodash";
export default now;


code:
import { nth } from "lodash";
export default nth;


code:
import { nthArg } from "lodash";
export default nthArg;


code:
import { default as clamp } from "./clamp";
import { default as inRange } from "./inRange";
import { default as random } from "./random";

export { default } from "./number.default";


code:
import clamp from "./clamp";
import inRange from "./inRange";
import random from "./random";

declare const defaultExport: {
    clamp: typeof clamp;
    inRange: typeof inRange;
    random: typeof random;
};
export default defaultExport;


code:
import { default as assign } from "./assign";
import { default as assignIn } from "./assignIn";
import { default as assignInWith } from "./assignInWith";
import { default as assignWith } from "./assignWith";
import { default as at } from "./at";
import { default as create } from "./create";
import { default as defaults } from "./defaults";
import { default as defaultsDeep } from "./defaultsDeep";
import { default as entries } from "./entries";
import { default as entriesIn } from "./entriesIn";
import { default as extend } from "./extend";
import { default as extendWith } from "./extendWith";
import { default as findKey } from "./findKey";
import { default as findLastKey } from "./findLastKey";
import { default as forIn } from "./forIn";
import { default as forInRight } from "./forInRight";
import { default as forOwn } from "./forOwn";
import { default as forOwnRight } from "./forOwnRight";
import { default as functions } from "./functions";
import { default as functionsIn } from "./functionsIn";
import { default as get } from "./get";
import { default as has } from "./has";
import { default as hasIn } from "./hasIn";
import { default as invert } from "./invert";
import { default as invertBy } from "./invertBy";
import { default as invoke } from "./invoke";
import { default as keys } from "./keys";
import { default as keysIn } from "./keysIn";
import { default as mapKeys } from "./mapKeys";
import { default as mapValues } from "./mapValues";
import { default as merge } from "./merge";
import { default as mergeWith } from "./mergeWith";
import { default as omit } from "./omit";
import { default as omitBy } from "./omitBy";
import { default as pick } from "./pick";
import { default as pickBy } from "./pickBy";
import { default as result } from "./result";
import { default as set } from "./set";
import { default as setWith } from "./setWith";
import { default as toPairs } from "./toPairs";
import { default as toPairsIn } from "./toPairsIn";
import { default as transform } from "./transform";
import { default as unset } from "./unset";
import { default as update } from "./update";
import { default as updateWith } from "./updateWith";
import { default as values } from "./values";
import { default as valuesIn } from "./valuesIn";

export { default } from "./object.default";


code:
import assign from "./assign";
import assignIn from "./assignIn";
import assignInWith from "./assignInWith";
import assignWith from "./assignWith";
import at from "./at";
import create from "./create";
import defaults from "./defaults";
import defaultsDeep from "./defaultsDeep";
import entries from "./entries";
import entriesIn from "./entriesIn";
import extend from "./extend";
import extendWith from "./extendWith";
import findKey from "./findKey";
import findLastKey from "./findLastKey";
import forIn from "./forIn";
import forInRight from "./forInRight";
import forOwn from "./forOwn";
import forOwnRight from "./forOwnRight";
import functions from "./functions";
import functionsIn from "./functionsIn";
import get from "./get";
import has from "./has";
import hasIn from "./hasIn";
import invert from "./invert";
import invertBy from "./invertBy";
import invoke from "./invoke";
import keys from "./keys";
import keysIn from "./keysIn";
import mapKeys from "./mapKeys";
import mapValues from "./mapValues";
import merge from "./merge";
import mergeWith from "./mergeWith";
import omit from "./omit";
import omitBy from "./omitBy";
import pick from "./pick";
import pickBy from "./pickBy";
import result from "./result";
import set from "./set";
import setWith from "./setWith";
import toPairs from "./toPairs";
import toPairsIn from "./toPairsIn";
import transform from "./transform";
import unset from "./unset";
import update from "./update";
import updateWith from "./updateWith";
import values from "./values";
import valuesIn from "./valuesIn";

declare const defaultExport: {
    assign: typeof assign;
    assignIn: typeof assignIn;
    assignInWith: typeof assignInWith;
    assignWith: typeof assignWith;
    at: typeof at;
    create: typeof create;
    defaults: typeof defaults;
    defaultsDeep: typeof defaultsDeep;
    entries: typeof entries;
    entriesIn: typeof entriesIn;
    extend: typeof extend;
    extendWith: typeof extendWith;
    findKey: typeof findKey;
    findLastKey: typeof findLastKey;
    forIn: typeof forIn;
    forInRight: typeof forInRight;
    forOwn: typeof forOwn;
    forOwnRight: typeof forOwnRight;
    functions: typeof functions;
    functionsIn: typeof functionsIn;
    get: typeof get;
    has: typeof has;
    hasIn: typeof hasIn;
    invert: typeof invert;
    invertBy: typeof invertBy;
    invoke: typeof invoke;
    keys: typeof keys;
    keysIn: typeof keysIn;
    mapKeys: typeof mapKeys;
    mapValues: typeof mapValues;
    merge: typeof merge;
    mergeWith: typeof mergeWith;
    omit: typeof omit;
    omitBy: typeof omitBy;
    pick: typeof pick;
    pickBy: typeof pickBy;
    result: typeof result;
    set: typeof set;
    setWith: typeof setWith;
    toPairs: typeof toPairs;
    toPairsIn: typeof toPairsIn;
    transform: typeof transform;
    unset: typeof unset;
    update: typeof update;
    updateWith: typeof updateWith;
    values: typeof values;
    valuesIn: typeof valuesIn;
};
export default defaultExport;


code:
import { omit } from "lodash";
export default omit;


code:
import { omitBy } from "lodash";
export default omitBy;


code:
import { once } from "lodash";
export default once;


code:
import { orderBy } from "lodash";
export default orderBy;


code:
import { over } from "lodash";
export default over;


code:
import { overArgs } from "lodash";
export default overArgs;


code:
import { overEvery } from "lodash";
export default overEvery;


code:
import { overSome } from "lodash";
export default overSome;


@types/lodash-es

description: TypeScript definitions for lodash-es

Stephen Lautier

githubUsername: stephenlautier

e-cloud

githubUsername: e-cloud

type: module

directory: types/lodash-es


code:
import { pad } from "lodash";
export default pad;


code:
import { padEnd } from "lodash";
export default padEnd;


code:
import { padStart } from "lodash";
export default padStart;


code:
import { parseInt } from "lodash";
export default parseInt;


code:
import { partial } from "lodash";
export default partial;


code:
import { partialRight } from "lodash";
export default partialRight;


code:
import { partition } from "lodash";
export default partition;


code:
import { pick } from "lodash";
export default pick;


code:
import { pickBy } from "lodash";
export default pickBy;


code:
import { property, PropertyPath } from "lodash";

export { PropertyPath };
export default property;


code:
import { propertyOf } from "lodash";
export default propertyOf;


code:
import { pull } from "lodash";
export default pull;


code:
import { pullAll } from "lodash";
export default pullAll;


code:
import { pullAllBy } from "lodash";
export default pullAllBy;


code:
import { pullAllWith } from "lodash";
export default pullAllWith;


code:
import { pullAt } from "lodash";
export default pullAt;


code:
import { random } from "lodash";
export default random;


code:
import { range } from "lodash";
export default range;


code:
import { rangeRight } from "lodash";
export default rangeRight;


code:
import { rearg } from "lodash";
export default rearg;


code:
import { reduce } from "lodash";
export default reduce;


code:
import { reduceRight } from "lodash";
export default reduceRight;


code:
import { reject } from "lodash";
export default reject;


code:
import { remove } from "lodash";
export default remove;


code:
import { repeat } from "lodash";
export default repeat;


code:
import { replace } from "lodash";
export default replace;


code:
import { rest } from "lodash";
export default rest;


code:
import { result } from "lodash";
export default result;


code:
import { reverse } from "lodash";
export default reverse;


code:
import { round } from "lodash";
export default round;


code:
import { sample } from "lodash";
export default sample;


code:
import { sampleSize } from "lodash";
export default sampleSize;


code:
import { set } from "lodash";
export default set;


code:
import { setWith } from "lodash";
export default setWith;


code:
import { shuffle } from "lodash";
export default shuffle;


code:
import { size } from "lodash";
export default size;


code:
import { slice } from "lodash";
export default slice;


code:
import { snakeCase } from "lodash";
export default snakeCase;


code:
import { some } from "lodash";
export default some;


code:
import { sortBy } from "lodash";
export default sortBy;


code:
import { sortedIndex } from "lodash";
export default sortedIndex;


code:
import { sortedIndexBy } from "lodash";
export default sortedIndexBy;


code:
import { sortedIndexOf } from "lodash";
export default sortedIndexOf;


code:
import { sortedLastIndex } from "lodash";
export default sortedLastIndex;


code:
import { sortedLastIndexBy } from "lodash";
export default sortedLastIndexBy;


code:
import { sortedLastIndexOf } from "lodash";
export default sortedLastIndexOf;


code:
import { sortedUniq } from "lodash";
export default sortedUniq;


code:
import { sortedUniqBy } from "lodash";
export default sortedUniqBy;


code:
import { split } from "lodash";
export default split;


code:
import { spread } from "lodash";
export default spread;


code:
import { startCase } from "lodash";
export default startCase;


code:
import { startsWith } from "lodash";
export default startsWith;


code:
import { default as camelCase } from "./camelCase";
import { default as capitalize } from "./capitalize";
import { default as deburr } from "./deburr";
import { default as endsWith } from "./endsWith";
import { default as escape } from "./escape";
import { default as escapeRegExp } from "./escapeRegExp";
import { default as kebabCase } from "./kebabCase";
import { default as lowerCase } from "./lowerCase";
import { default as lowerFirst } from "./lowerFirst";
import { default as pad } from "./pad";
import { default as padEnd } from "./padEnd";
import { default as padStart } from "./padStart";
import { default as parseInt } from "./parseInt";
import { default as repeat } from "./repeat";
import { default as replace } from "./replace";
import { default as snakeCase } from "./snakeCase";
import { default as split } from "./split";
import { default as startCase } from "./startCase";
import { default as startsWith } from "./startsWith";
import { default as template } from "./template";
import { default as templateSettings } from "./templateSettings";
import { default as toLower } from "./toLower";
import { default as toUpper } from "./toUpper";
import { default as trim } from "./trim";
import { default as trimEnd } from "./trimEnd";
import { default as trimStart } from "./trimStart";
import { default as truncate } from "./truncate";
import { default as unescape } from "./unescape";
import { default as upperCase } from "./upperCase";
import { default as upperFirst } from "./upperFirst";
import { default as words } from "./words";

export { default } from "./string.default";


code:
import camelCase from "./camelCase";
import capitalize from "./capitalize";
import deburr from "./deburr";
import endsWith from "./endsWith";
import escape from "./escape";
import escapeRegExp from "./escapeRegExp";
import kebabCase from "./kebabCase";
import lowerCase from "./lowerCase";
import lowerFirst from "./lowerFirst";
import pad from "./pad";
import padEnd from "./padEnd";
import padStart from "./padStart";
import parseInt from "./parseInt";
import repeat from "./repeat";
import replace from "./replace";
import snakeCase from "./snakeCase";
import split from "./split";
import startCase from "./startCase";
import startsWith from "./startsWith";
import template from "./template";
import templateSettings from "./templateSettings";
import toLower from "./toLower";
import toUpper from "./toUpper";
import trim from "./trim";
import trimEnd from "./trimEnd";
import trimStart from "./trimStart";
import truncate from "./truncate";
import unescape from "./unescape";
import upperCase from "./upperCase";
import upperFirst from "./upperFirst";
import words from "./words";

declare const defaultExport: {
    camelCase: typeof camelCase;
    capitalize: typeof capitalize;
    deburr: typeof deburr;
    endsWith: typeof endsWith;
    escape: typeof escape;
    escapeRegExp: typeof escapeRegExp;
    kebabCase: typeof kebabCase;
    lowerCase: typeof lowerCase;
    lowerFirst: typeof lowerFirst;
    pad: typeof pad;
    padEnd: typeof padEnd;
    padStart: typeof padStart;
    parseInt: typeof parseInt;
    repeat: typeof repeat;
    replace: typeof replace;
    snakeCase: typeof snakeCase;
    split: typeof split;
    startCase: typeof startCase;
    startsWith: typeof startsWith;
    template: typeof template;
    templateSettings: typeof templateSettings;
    toLower: typeof toLower;
    toUpper: typeof toUpper;
    trim: typeof trim;
    trimEnd: typeof trimEnd;
    trimStart: typeof trimStart;
    truncate: typeof truncate;
    unescape: typeof unescape;
    upperCase: typeof upperCase;
    upperFirst: typeof upperFirst;
    words: typeof words;
};
export default defaultExport;


code:
import { stubArray } from "lodash";
export default stubArray;


code:
import { stubFalse } from "lodash";
export default stubFalse;


code:
import { stubObject } from "lodash";
export default stubObject;


code:
import { stubString } from "lodash";
export default stubString;


code:
import { stubTrue } from "lodash";
export default stubTrue;


code:
import { subtract } from "lodash";
export default subtract;


code:
import { sum } from "lodash";
export default sum;


code:
import { sumBy } from "lodash";
export default sumBy;


code:
import { tail } from "lodash";
export default tail;


code:
import { take } from "lodash";
export default take;


code:
import { takeRight } from "lodash";
export default takeRight;


code:
import { takeRightWhile } from "lodash";
export default takeRightWhile;


code:
import { takeWhile } from "lodash";
export default takeWhile;


code:
import { tap } from "lodash";
export default tap;


code:
import { template } from "lodash";
export default template;


code:
import { templateSettings } from "lodash";
export default templateSettings;


code:
import { throttle, ThrottleSettings } from "lodash";

export { ThrottleSettings };
export default throttle;


code:
import { thru } from "lodash";
export default thru;


code:
import { times } from "lodash";
export default times;


code:
import { toArray } from "lodash";
export default toArray;


code:
import { toFinite } from "lodash";
export default toFinite;


code:
import { toInteger } from "lodash";
export default toInteger;


code:
import { toLength } from "lodash";
export default toLength;


code:
import { toLower } from "lodash";
export default toLower;


code:
import { toNumber } from "lodash";
export default toNumber;


code:
import { toPairs } from "lodash";
export default toPairs;


code:
import { toPairsIn } from "lodash";
export default toPairsIn;


code:
import { toPath } from "lodash";
export default toPath;


code:
import { toPlainObject } from "lodash";
export default toPlainObject;


code:
import { toSafeInteger } from "lodash";
export default toSafeInteger;


code:
import { toString } from "lodash";
export default toString;


code:
import { toUpper } from "lodash";
export default toUpper;


code:
import { transform } from "lodash";
export default transform;


code:
import { trim } from "lodash";
export default trim;


code:
import { trimEnd } from "lodash";
export default trimEnd;


code:
import { trimStart } from "lodash";
export default trimStart;


code:
import { truncate } from "lodash";
export default truncate;


code:
import { unary } from "lodash";
export default unary;


code:
import { unescape } from "lodash";
export default unescape;


code:
import { union } from "lodash";
export default union;


code:
import { unionBy } from "lodash";
export default unionBy;


code:
import { unionWith } from "lodash";
export default unionWith;


code:
import { uniq } from "lodash";
export default uniq;


code:
import { uniqBy } from "lodash";
export default uniqBy;


code:
import { uniqWith } from "lodash";
export default uniqWith;


code:
import { uniqueId } from "lodash";
export default uniqueId;


code:
import { unset } from "lodash";
export default unset;


code:
import { unzip } from "lodash";
export default unzip;


code:
import { unzipWith } from "lodash";
export default unzipWith;


code:
import { update } from "lodash";
export default update;


code:
import { updateWith } from "lodash";
export default updateWith;


code:
import { upperCase } from "lodash";
export default upperCase;


code:
import { upperFirst } from "lodash";
export default upperFirst;


code:
import { default as attempt } from "./attempt";
import { default as bindAll } from "./bindAll";
import { default as cond } from "./cond";
import { default as conforms } from "./conforms";
import { default as constant } from "./constant";
import { default as defaultTo } from "./defaultTo";
import { default as flow } from "./flow";
import { default as flowRight } from "./flowRight";
import { default as identity } from "./identity";
import { default as iteratee } from "./iteratee";
import { default as matches } from "./matches";
import { default as matchesProperty } from "./matchesProperty";
import { default as method } from "./method";
import { default as methodOf } from "./methodOf";
import { default as mixin } from "./mixin";
import { default as noop } from "./noop";
import { default as nthArg } from "./nthArg";
import { default as over } from "./over";
import { default as overEvery } from "./overEvery";
import { default as overSome } from "./overSome";
import { default as property } from "./property";
import { default as propertyOf } from "./propertyOf";
import { default as range } from "./range";
import { default as rangeRight } from "./rangeRight";
import { default as stubArray } from "./stubArray";
import { default as stubFalse } from "./stubFalse";
import { default as stubObject } from "./stubObject";
import { default as stubString } from "./stubString";
import { default as stubTrue } from "./stubTrue";
import { default as times } from "./times";
import { default as toPath } from "./toPath";
import { default as uniqueId } from "./uniqueId";

export { default } from "./util.default";