\n\nJUSTUS\n======\n\n> _\"**justus**\"_ (latin, adj.): _\"proper\"_ or _\"correct\"_.\n\nJUSTUS is a very simple library for _validating_ JavaScript objects and\nproperly _annotating_ them with TypeScript types.\n\nIt focuses in providing an _easy_ and _terse_ syntax to define a simple schema,\nused to ensure that an object is _**correct**_ and from which _**proper**_\ntyping can be inferred.\n\n- [Quick Start](#quick-start)\n- [Inferring Types](#inferring-types)\n- Validators\n - [Strings](#string-validator)\n - [Numbers](#number-validator)\n - [Booleans](#boolean-validator)\n - [Constants](#constant-validator)\n - [Any](#any-validator)\n - [Arrays](#array-validator)\n - [Dates](#date-validator)\n - [Tuples](#tuple-validator)\n - [Objects](#object-validator) (yes, this is the important one!!!)\n - [Optionals](#optional-validator)\n - [Any of, all of](#union-validators)\n- [Extra Validators](#extra-validators)\n- [Validation Options](#validation-options)\n- [A (slightly more) complex example](#a-complex-example)\n- [Generating DTS files](#generating-dts-files)\n- [Copyright Notice](NOTICE.md)\n- [License](LICENSE.md)\n\nQuick Start\n-----------\n\nYou can use JUSTUS in your projects quite simply: import, write a schema and\nvalidate. For example:\n\n```typescript\nimport { number, object, string, validate } from 'justus'\n\n// Create a validator, validating _objects_ with a specific schema\nconst validator = object({\n // The \"foo\" property in the objects to validate must be a \"string\"\n // with a minimum length of one character\n foo: string({ minLength: 1 }),\n\n // The \"bar\" property in the objects to validate must be a \"number\"\n bar: number,\n\n // Always use `as const`: it correctly infers types for constants, tuples, ...\n} as const)\n\n// Use the validator to validate the object specified as the second argument\nconst validated = validate(validator, { foo: 'xyz', bar: 123 })\n\nvalidated.foo // <-- its type will be \"string\"\nvalidated.bar // <-- its type will be \"number\"\n```\n\nEasy, terse, ultimately very readable... And all types are inferred!\n\n#### Shorthand syntax\n\nThe `validate` function (or anywhere a _validation_ is needed) can accept a\n_shorthand_ inline syntax. From our example above:\n\n```typescript\nimport { number, string, validate } from 'justus'\n\nconst validated = validate(\n {\n foo: string({ minLength: 1 }),\n bar: number,\n } as const,\n {\n foo: 'xyz',\n bar: 123,\n },\n)\n```\n\n... you get the drill! See below in each _validator_ for their shorthand syntax.\n\nInferring Types\n---------------\n\nIt is sometimes useful to have access to the inferred types produced by the\nvalidation function. The `InferValidation` type does just that:\n\n```typescript\nconst myTypeValidator = object({\n /* a required string, with minimum length of 1 character */\n foo: string({ minLength: 1 }),\n /* an optional number, defaulted to 12345 */\n bar: optional(number, 12345),\n /* an optional date, without default */\n baz: optional(date),\n} as const)\n\ntype MyValidatedType = InferValidation\n// here \"MyValidatedType\" will have the following shape:\n// {\n// foo: string, // plain \"string\"\n// bar: number, // optional _with_ a default\n// baz?: Date | undefined , // optional _without_ a default\n// }\n```\n\nSimilarly, it might be useful to have access to a minimal type required as a\nvalidation input. This obviously differs from the input for several reasons,\nlike:\n\n- optionals with default: on input we should represent `optional(type, default)`\n as `type`, but on input this should be `type | undefined`\n- type conversions: the `date` validator converts numbers or strings always\n into `Date` objects, but the input type should be `Date | string | number`\n\nThe `InferInput` helps in this case:\n\n```typescript\nconst myTypeValidator = object({\n /* a required string, with minimum length of 1 character */\n foo: string({ minLength: 1 }),\n /* an optional number, defaulted to 12345 */\n bar: optional(number, 12345),\n /* an optional date, without default */\n baz: optional(date),\n} as const)\n\ntype MyInputType = InferInput\n// here \"MyInputType\" will have the following shape:\n// {\n// foo: string, // plain string\n// bar?: number | undefined, // optional, as it has a default\n// baz?: Date | string | number | undefined, // optional, also parsed from string, number\n// }\n```\n\nString Validator\n----------------\n\nString validators are created using the `string` function:\n\n```typescript\nimport { string } from 'justus'\n\nconst s1 = string // validates any string\nconst s2 = string({ minLength: 1 }) // validate non empty strings\n```\n\n#### Options\n\n- `minLength?: number`: The _minimum_ length of a valid `string`\n- `maxLength?: number`: The _maximum_ length of a valid `string`\n- `pattern?: RegExp`: A `RegExp` enforcing a particular pattern for a valid `string`\n\n#### Branded strings\n\nType _branding_ can be used for string primitives. For example:\n\n```typescript\nimport { string, validate } from 'justus'\n\ntype UUID = string & { __brand_uuid: never }\n\nconst uuidValidator = string({\n pattern: /^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/,\n minLength: 36,\n maxLength: 36,\n})\n\nconst value = validate(uuidValidator, 'C274773D-1444-41E1-9D3A-9F9D584FE8B5')\n\nvalue = 'foo' // <- will fail, as \"foo\" is a `string`, while \"value\" is a `UUID`\n```\n\n#### Implicit branding\n\nSometimes it might be useful to declare the _branding_ of a string without\nrecurring to an external type. We can easily do so by adding the `brand`\nproperty our string constraints. Following the example above:\n\n```typescript\nimport { string, validate } from 'justus'\n\nconst uuidValidator = string({\n pattern: /^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/,\n minLength: 36,\n maxLength: 36,\n brand: 'uuid',\n})\n\nconst value = validate(uuidValidator, 'C274773D-1444-41E1-9D3A-9F9D584FE8B5')\n\nvalue = 'foo' // <- fail! the type of \"value\" is \"string & __brand_uuid: never\"\n```\n\n#### Shorthand syntax\n\nThe shorthand syntax for string validators is simply `string`. For example:\n\n```typescript\nimport { object, string } from 'justus'\n\nconst validator = object({\n foo: string, // yep, no parenthesis, just \"string\"\n})\n```\n\nNumber Validator\n----------------\n\nNumber validators are created using the `number` function:\n\n```typescript\nimport { number } from 'justus'\n\nconst n1 = number // validates any number\nconst n2 = number({ minimum: 123 }) // validate numbers 123 and greater\nconst n3 = number({ fromString: true }) // parse strings like \"12.34\" or \"0x0CAFE\"\n```\n\n#### Options\n\n- `multipleOf?: number`: The value for which a `number` must be multiple of for it to be valid\n- `maximum?: number`: The _inclusive_ maximum value for a valid `number`\n- `minimum?: number`: The _inclusive_ minimum value for a valid `number`\n- `exclusiveMaximum?: number`: The _exclusive_ maximum value for a valid `number`\n- `exclusiveMinimum?: number`: The _exclusive_ minimum value for a valid `number`\n- `allowNaN?: boolean`: Whether to allow `NaN` or not (default: `false`)\n- `fromString?: boolean`: Whether to parse numbers from strings or not (default: `false`)\n\n#### Branded numbers\n\nType _branding_ can be used for number primitives. For example:\n\n```typescript\nimport { number, validate } from 'justus'\n\ntype Price = number & { __brand_price: never }\n\nconst priceValidator = number({\n multipleOf: 0.01, // cents, anyone? :-)\n minimum: 0, // no negative prices, those are _discounts_\n})\n\nconst value = validate(priceValidator, 123.45)\n\nvalue = 432 // <- will fail, as 432 is a `number`, while \"value\" is a `Price`\n```\n\n#### Implicit branding\n\nSometimes it might be useful to declare the _branding_ of a number without\nrecurring to an external type. We can easily do so by adding the `brand`\nproperty our number constraints. Following the example above:\n\n```typescript\nimport { number, validate } from 'justus'\n\nconst priceValidator = number({\n multipleOf: 0.01, // cents, anyone? :-)\n minimum: 0, // no negative prices, those are _discounts_\n brand: 'price',\n})\n\nconst value = validate(priceValidator, 123.45)\n\nvalue = 432 // <- fail! the type of \"value\" is \"number & __brand_price: never\"\n```\n\n#### Shorthand syntax\n\nThe shorthand syntax for number validators is simply `number`. For example:\n\n```typescript\nimport { number, object } from 'justus'\n\nconst validator = object({\n foo: number, // yep, no parenthesis, just \"number\"\n})\n```\n\nBoolean Validator\n-----------------\n\nThe boolean validator is represented by the `boolean` constant:\n\n```typescript\nimport { boolean, object } from 'justus'\n\nconst validator = object({\n foo: boolean, // it's a constant, no options!\n})\n```\n\nTo validate the string `true` or `false` as booleans, simply create the\nvalidator with the `fromString` option (defaults to `false`):\n\n```typescript\nimport { boolean, object, validate } from 'justus'\n\nconst validator = object({\n foo: boolean({ fromString: true }),\n})\n\n// Here myValue can be a boolean or the string \"true\" or \"false\" (case insensitive)\nconst bool = validate(validator, myValue)\n```\n\nConstant Validator\n------------------\n\nCosntant validators are created using the `constant` function:\n\n```typescript\nimport { constant } from 'justus'\n\nconst c1 = constant('foo') // validates the `string` constant \"foo\"\nconst c2 = constant(12345) // validates the `number` constant 12345\nconst c3 = constant(false) // validates the `boolean` constant `false`\nconst c4 = constant(null) // validates the `null` constant\n```\n\nThe constant validator requires a `string`, `number`, `boolean` or `null`\nconstant.\n\n#### Shorthand syntax\n\nThe shorthand syntax for constant validators is simply its value. For example:\n\n```typescript\nimport { object, validate } from 'justus'\n\nconst validator = object({\n foo: 'foo', // the string \"foo\"\n bar: 12345, // the number 12345\n baz: false, // the boolean false\n nil: null, // the null constant\n} as const) // yep, don't forget \"as const\" to infer types correctly\n\nconst result = validate(validator, something)\n\nresult.foo // <- its type will be `\"foo\"` (or \"string\" if you didn't use \"as const\")\nresult.bar // <- its type will be `12345` (or \"number\" if you didn't use \"as const\")\nresult.baz // <- its type will be `false` (or \"boolean\" if you didn't use \"as const\")\nresult.nil // <- its type will be `null` (or \"any\" if you didn't use \"as const\")\n```\n\nAny Validator\n-------------\n\nThe _any_ validator is represented by the `any` constant:\n\n```typescript\nimport { any, object, validate } from 'justus'\n\nconst validator = object({\n foo: any, // it's a constant, no options!\n})\n\nconst result = validate(validator, something)\n\nresult.foo // <- its type will be `any`\n```\n\nArray Validator\n---------------\n\nArray validators are created using the `array` or `arrayOf` functions:\n\n```typescript\nimport { array, arrayOf, number, string } from 'justus'\n\nconst a1 = array // validates any array\nconst a2 = array({ maxItems: 10, items: string }) // array of strings\nconst a3 = arrayOf(number) // array of numbers\n```\n\n#### Options\n\n- `maxItems?: number`: The _maximum_ number of elements a valid `Array`\n- `minItems?: number`: The _minimum_ number of elements a valid `Array`\n- `uniqueItems?: boolean`: Indicates if the `Array`'s elements must be unique\n- `items?: V`: The _type_ of each individual item in the `Array` */\n\n#### Shorthand syntax\n\nThe shorthand syntax for string validators is simply `array`. For example:\n\n```typescript\nimport { array, object } from 'justus'\n\nconst validator = object({\n foo: array, // validate any array, of any length, containing anything\n})\n```\n\nThe `arrayOf` function can also be considered a _shorthand_ of the full\n`array({ items: ... })`. For example the two following declarations are\nequivalent:\n\n```typescript\nimport { array, arrayOf, string } from 'justus'\n\nconst a1 = array({ items: string })\nconst a2 = arrayOf(string) // same as above, just more readable\n```\n\nDate Validator\n--------------\n\nDate validators are created using the `date` function:\n\n```typescript\nimport { date } from 'justus'\n\nconst d1 = date // validates any date\nconst d2 = date({ format: 'iso' }) // validate ISO dates\n```\n\n> **NOTE:** Date validators also _convert_ dates (in string format), or\n> timestamps (milliseconds from the epoch) into proper `Date` instances.\n\n#### Options\n\n- `format?: 'iso' | 'timestamp'`: The format for dates, `iso` for _ISO Dates_\n (as outlined in RFC 3339) or `timestamp` for the number of milliseconds since\n the epoch\n- `from?: Date`: The earliest value a date can have\n- `until?: Date`: The latest value a date can have\n\n#### Shorthand syntax\n\nThe shorthand syntax for number validators is simply `date`. For example:\n\n```typescript\nimport { date, object } from 'justus'\n\nconst validator = object({\n foo: date, // anything that can be converted to `Date` will be!\n})\n```\n\nTuple Validator\n---------------\n\nA _tuple_ is (by definition) _a finite ordered list (sequence) of elements_.\n\nTuple validators are created using the `tuple` function:\n\n```typescript\nimport { tuple, string, number, boolean } from 'justus'\n\n// Validates 3 elements tuple: (in order) a string, a number and a boolean\nconst t1 = tuple([string, number, boolean])\n\n// Validates a tuple whose first element is a string, followed by zero or more\n// numbers, and wholse last element is a boolean\nconst t2 = tuple([string, ...number, boolean]) // yay! rest parameters!\n```\n\nAs shown above, any `Validator` (or one of its shorthands) can be used as a\n_rest parameter_ implying zero or more elements of the specified kind.\n\nA more complex example:\n\n```typescript\nimport { number, object, string, tuple, validate } from 'justus'\n\nconst myObject = object({\n version: number,\n title: string,\n})\n\n// This is the silliest tuple ever written, but outlines our intentions:\nconst sillyTuple = tuple(['start', ...myObject, 'end'] as const)\n\n// Validate using our tuple:\nvalidate(sillyTuple, [\n 'start', // yep, a constant\n { version: 1, title: 'Hello world' },\n { version: 2, title: 'Foo, bar and baz' },\n 'end', // the last\n])\n```\n\nObject Validator\n----------------\n\nAs seen in the examples above, object validators are created using the\n`object` function:\n\n```typescript\nimport { object, string, number } from 'justus'\n\nconst o1 = object // any object (excluding null - darn JavaScript)\nconst o2 = object({\n foo: string, // any string\n bar: number, // any number\n baz: 'Hello, world!', // the constant \"Hello, world!\"\n} as const)\n```\n\n#### Shorthand syntax\n\nThe shorthand syntax for object validators is simply `object`. For example:\n\n```typescript\nimport { arrayOf, object } from 'justus'\n\nconst validator = arrayOf(object) // won't validate if the array has numbers, strings, ...\n```\n\n#### Allow additional properties\n\nSometimes it's necessary to allow additional properties in an object.\n\nDestructuring `...allowAdditionalProperties` in an objects does the trick!\n\n```typescript\nimport { allowAdditionalProperties, boolean, number, object, string, validate } from 'justus'\n\nconst o1 = object({\n foo: string, // any string\n bar: number, // any number\n ...allowAdditionalProperties, // any other key will be \"any\"\n})\n\nconst result1 = validate(o1, something)\n\nresult1.foo // <-- this will be a \"string\"\nresult1.bar // <-- this will be a \"number\"\nresult1.baz // <-- additional property, this will be \"any\"\n\n// additional properties with a type\n\nconst o2 = object({\n foo: string, // any string\n bar: number, // any number\n ...allowAdditionalProperties(boolean), // any other key will be \"boolean\"\n})\n\nconst result2 = validate(o2, something)\n\nresult2.foo // <-- this will be a \"string\"\nresult2.bar // <-- this will be a \"number\"\nresult2.baz // <-- additional property, this will be \"boolean\"\n```\n\nHere `allowAdditionalProperties` is also a function, which can take some\nparameters to configure its behaviour:\n\n- `...allowAdditionalProperties`: default shorthand, allows additional\n properties and will infer the `any` type for them.\n- `...allowAdditionalProperties()`: as a function, and same as above, it allows\n additional properties and will infer the `any` type for them.\n- `...allowAdditionalProperties(true)`: as a function, and same as above, it\n allows additional properties and will infer the `any` type for them.\n- `...allowAdditionalProperties(false)`: as a function, it _forbids_ any\n additional property in objects, useful when extending objects (see below)\n- `...allowAdditionalProperties(... type ...)`: as a function, it allows\n additional properties in objects and ensures their type is correct\n\n#### Extending objects\n\nSimply destructure one into another. For example:\n\n```typescript\nimport { object, string, number, boolean } from 'justus'\n\nconst o1 = object({\n foo: string, // any string\n bar: number, // any number\n})\n\nconst o2 = object({\n ...o1, // anything part of \"o1\" will be here as well!\n bar: boolean, // here \"bar\" is no longer a number, but a boolean\n baz: number, // add the \"baz\" property as a number\n} as const)\n```\n\nA slightly more complex scenario arises when considering additional properties\nin the base object, but forcedly forbidding them in an extend one.\n\nTo do so, simply override in the extended object as follows:\n\nSimply destructure one into another. For example:\n\n```typescript\nimport { allowAdditionalProperties, boolean, number, object, string } from 'justus'\n\nconst o1 = object({\n foo: string, // any string\n bar: number, // any number\n ...allowAdditionalProperties(boolean), // any other property is a boolean\n})\n\nconst o2 = object({\n ...o1, // anything part of \"o1\" will be here as well!\n baz: boolean, // add \"baz\" to \"o1\", forcing it to be a \"boolean\"\n ...allowAdditionalProperties(false), // no more additional properties here!\n} as const)\n```\n\n#### Ensure properties never exist\n\nWhen allowing extra properties, or extending objects, we might want to validate\nthe _non-existance_ of a specific property. We can do this setting a property\nto `never`.\n\n```typescript\nimport { allowAdditionalProperties, never, number, object, string } from 'justus'\n\nconst o1 = object({\n foo: string, // any string\n bar: number, // any number\n})\n\nconst o2 = object({\n ...o1, // anything part of \"o1\" will be here as well!\n bar: never, // remove \"bar\" from the properties inherited by \"o1\"\n} as const)\n\nconst o3 = object({\n ...o1, // anything part of \"o1\" will be here as well!\n ...allowAdditionalProperties, // allow additional properties as \"any\"\n baz: never, // even with additional properties, \"baz\" must not exist\n} as const)\n```\n\n#### Simple records\n\nWhen attempting to validate a simple `Record` the\nfunction `objectOf` can come handy:\n\n```typescript\nimport { objectOf, number } from 'justus'\n\nconst o1 = objectOf(number)\n// here \"o1\" will have the shape \"Record\"\"\n\nconst o2 = objectOf({ test: number })\n// here \"o2\" will have the shape \"Record\"\n```\n\nOptional Validator\n------------------\n\nOptional properties properties can also be declared in objects, arrays, ...:\n\n```typescript\nimport { object, arrayOf, optional, string, number, validate } from 'justus'\n\nconst o1 = object({\n foo: string, // any string, but must be a string\n bar: optional(number), // optional property as \"number | undefined\"\n})\n\nconst r1 = validate(o1, something)\n// here \"r1\" will have a shape like \"{ foo: string, bar?: number | undefined }\"\n\nconst o2 = arrayOf(optional(string)) // array members will be \"string | undefined\"\nconst r2 = validate(o2, something)\n// here \"r2\" will have a shape like \"(string | undefined)[]\"\n```\n\nThe optional validator can _also_ be used to inject _default values_ in case\nthe source object doesn't have one. To do so, we can simply use the _second_\nparameter of our `optional(...)` function:\n\n```typescript\nimport { object, optional, number, validate } from 'justus'\n\nconst o1 = object({\n foo: optional(number, 123), // any number, default is 123\n})\n\nconst r1 = validate(o1, {})\n// here \"r1\" will be \"{ foo: 123 }\" (the default value)\n\nconst r2 = validate(o1, { foo: 321 })\n// here \"r2\" will be \"{ foo: 321 }\" (overrides the default value)\n```\n\nUnion Validators\n----------------\n\nUnions (either _all_ or _any_) are defined using the `allOf` or `oneOf`\nfunctions.\n\nTo make sure all validations pass use `allOf`:\n\n```typescript\nimport { allOf, number, object, string, validate } from 'justus'\n\nconst o1 = object({ foo: string })\nconst o2 = object({ bar: number })\n\nconst result = validate(allOf(o1, o2), something)\n// result here will have the type of what's inferred by o1 _and_ o2\n\nresult.foo // <-- this is a \"string\"\nresult.bar // <-- this is a \"number\"\n\n// be careful about never!\nconst result2 = validate(allOf(number, string), something)\n// obviously \"result2\" will be of type \"never\" as \"number\" and \"string\" do not match!\n```\n\nMore useful, to make sure all validations pass use `oneOf`:\n\n```typescript\nimport { number, oneOf, string, validate } from 'justus'\n\nconst result = validate(oneOf(number, string), something)\n\nresult // <-- its type will be \"number | string\"\n```\n\nExtra Validators\n----------------\n\nA number of _extra_ validators are also included, but not exported by default\nin order to reduce the bundle size when Justus is bundled in client apps.\n\nThose are:\n\n- `arn`: Validate an ARN (Amazon Resource Name) as a string\n - `import { arn } from 'justus/extra/arn'`\n- `parseArn`: Validate an ARN (Amazon Resource Name) and parse its components\n - `import { parseArn } from 'justus/extra/arn'`\n- `ean13`: Validate a standard _EAN-13_ barcode number (as a string)\n - `import { ean13 } from 'justus/extra/ean13'`\n- `url`: Validate a string URL and converts it into a proper `URL` object\n - `import { url } from 'justus/extra/url'`\n- `uuid`: Validate a string UUID plain and simple\n - `import { uuid } from 'justus/extra/uuid'`\n\nValidation Options\n------------------\n\nThe `validate(...)` function accepts (as a third parameter) some validation\noptions. Those are:\n\n- `stripAdditionalProperties`: the `validate(...)` function will ignore any\n object property that was not declared in the schema, and will strip them\n out of the returned object (rather than failing).\n- `stripForbiddenProperties`: the `validate(...)` function will ignore any\n _forbidden_ property that was declared in the schema (for more info see\n [below](#ensure-properties-never-exist)), and will strip them out of the\n returned object (rather than failing).\n- `stripOptionalNulls`: the `validate(...)` function will ignore _optional_\n properties with `null` values and strip them out of the returned object.\n This is convenient when validating/stripping results coming from a database\n table, where columns are declared as _nullable_.\n\nThe `strip(...)` function is a convenience wrapper around `validate(...)`\nimplying `stripAdditionalProperties` and `stripOptionalNulls`. Therefore:\n\n```typescript\nimport { validate, strip } from 'justus'\n\nconst result1 = strip(schema, object)\n\n// is equivalent to\n\nconst result2 = validate(schema, object, {\n stripAdditionalProperties: true,\n stripForbiddenProperties: false,\n stripOptionalNulls: true,\n})\n```\n\nA complex example\n-----------------\n\nThis example is not complicated at all, but it outlines the simplicity\nof the syntax intended for JUSTUS.\n\nLet's assume we have some _time series_ data, but we can expect this in a\ncouple of different flavors, either V1 or V2 with some subtle differences:\n\n```typescript\nimport { arrayOf, date, number, object, oneOf, string, tuple, validate } from 'justus'\n\n// Our V1 time-series tuple is simply a timestamp followed by a numeric value\nconst entryv1 = tuple([date, number] as const)\n\n// Our V1 response from the time series database declares the version and data\nconst responsev1 = object({\n version: 1,\n entries: arrayOf(entryv1),\n} as const)\n\n// Our V2 time-series tuple is a timestamp, followed by a number and zero or\n// more strings indicating some remarks on the measurements\nconst entryv2 = tuple([date, number, ...string] as const)\n\n// Response for V2 is the same as V1, with some extra stuff\nconst responsev2 = object({\n version: 2,\n entries: arrayOf(entryv2),\n average: number, // this is extra!\n} as const)\n\n// Our combined response is either V1 or V2\nconst response = oneOf(responsev1, responsev2)\n\n// GO! Validate!\nconst result = validate(response, {})\n\nif (result.version === 1) {\n result.version // the type here will be the literal number 1\n result.entries.forEach((entry) => {\n entry[0] // this will be a `Date` instance\n entry[1] // this will be a \"number\"\n // entry[2] // will generate a typescript error\n })\n // response.average // will generate a typescript error\n} else {\n result.version // the type here will be the literal number 2\n result.entries.forEach((entry) => {\n entry[0] // this will be a `Date` instance\n entry[1] // this will be a \"number\"\n entry[2] // this will be a \"string\"\n entry[999] // this too will be a \"string\"\n })\n result.average // this will be a \"number\"\"\n}\n```\n\nGenerating DTS files\n--------------------\n\nSometimes it might be necessary to generate `.d.ts` files for your schemas,\nrather than relying on the type inference provided by JUSTUS.\n\nFor example, if you were to use JUSTUS on a server application to validate\nHTTP requests and responses, and wanted to have strong typing when interacting\nwith it from a client, you might not necessarily want to have JUSTUS (and your\nschemas) as a client dependency.\n\nSo, assuming your schemas might look something like this:\n\n```typescript\nimport { number, object, string } from 'justus'\n\n// this will be exported as a type\nconst uuid = string({ brand: 'uuid ' })\n\n// this will be embedded in product below\nconst price = number({ brand: 'price' })\n\n// object mapping two validators above\nconst product = object({\n uuid,\n price,\n name: string({ minLength: 1 }),\n})\n```\n\nWe can generate the DTS for `UUID` and `Product` (we specifically not export\n`Product` in this example) using our `dts-generator` as follows:\n\n```typescript\nimport { generateTypes } from 'justus/dts-generator'\n\n// Note how we rename the exports to \"UUID\" and \"Product\" (casing, ...)\nconst dts = generateTypes({\n UUID: uuid,\n Product: product,\n})\n```\n\nThe resulting `dts` will be a `string` containing the DTS as follows:\n\n```typescript\nexport type UUID = string & {\n __brand_uuid: never\n}\nexport type Product = {\n uuid: UUID\n price: number & {\n __brand_price: never\n }\n name: string\n}\n```\n","readmeFilename":"README.md"}
![\"logo\"](\"https://raw.githubusercontent.com/juitnow/justus/main/LOGO.svg\"){kind=logo}
\n