GitHub – DefinitelyTyped/DefinitelyTyped: The repository for high quality TypeScript type definitions.

Definitely Typed

The repository for high quality TypeScript type definitions .

You can besides read this README in Spanish, Korean, Russian, Chinese, Portuguese, italian and japanese !
liaison to Admin manual

Current status

This part tracks the health of the repository and publication procedure. It may be helpful for contributors experiencing any issues with their PRs and packages.

If anything here seems wrong, or any of the above are failing, please let us know in the Definitely Typed transmit on the TypeScript Community Discord server .

What are declaration files and how do I get them?

See the TypeScript handbook .


This is the favored method. For case :

npm install --save-dev @types/node

The types should then be mechanically included by the compiler. You may need to add a types reference if you’re not using modules :


See more in the handbook .
For an npm box “ foo ”, typings for it will be at “ @ types/foo ”. If you ca n’t find your package, look for it on TypeSearch .
If you distillery ca n’t find it, check if it bundles its own typings. This is normally provided in a "types" or "typings" field in the package.json, or just look for any “ .d.ts ” files in the software and manually include them with a /// .

Support Window

decidedly Typed only tests packages on versions of TypeScript that are less than 2 years old .

Currently versions 3.8 and above are tested…
If you’re using TypeScript 2.0 to 3.7, you can still try installing @types packages — the majority of packages do n’t use illusion new TypeScript features. But there ‘s no guarantee that they ‘ll work. here is the digest window :

@types packages have tags for versions of TypeScript that they explicitly support, so you can normally get older versions of packages that predate the 2-year windowpane. For example, if you run npm dist-tags @types/react, you ‘ll see that TypeScript 2.5 can use types for react @ 16.0, whereas TypeScript 2.6 and 2.7 can use types for react @ 16.4 :

Tag Version
latest 16.9.23
ts2.0 15.0.1
ts2.5 16.0.36
ts2.6 16.4.7
ts2.7 16.4.7

TypeScript 1.*

  • Manually download from the master branch of this repository and place them in your project
  • Typings (use preferred alternatives, typings is deprecated)
  • NuGet (use preferred alternatives, nuget DT type publishing has been turned off)

You may need to add manual references .

How can I contribute?

decidedly Typed entirely works because of contributions by users like you !


Before you plowshare your improvement with the earth, use the types yourself by creating a typename.d.ts file in your project and filling out its exports :

 declare module  `` libname ''  {
   // Types inside hera
   export  function  helloWorldMessage ( ):  string

Test editing an existing package

You can edit the types directly in node_modules/@types/foo/index.d.ts to validate your changes, then bring the changes to this repo with the steps below .
alternatively, you can use module augmentation to extend existing types from the DT module or use the declare module technique above which will override the version in node_modules .

Adding tests to a new package

Add to your tsconfig.json :

 `` baseUrl '':  




, `` typeRoots '': [





Create types/foo/index.d.ts containing declarations for the module “ foo ”. You should now be able to import from "foo" in your code and it will route to the new type definition. then build and run the code to make certain your type definition actually corresponds to what happens at runtime .
once you ‘ve tested your definitions with substantial code, make a PR then follow the instructions to edit an exist package or create a modern package .

Make a pull request

once you ‘ve tested your software, you can parcel it on Definitely Typed .
first, branching this repository, clone it, install node, and run npm install. If using npm v7 you need to add the --legacy-peer-deps flag to the command .
We use a bot to let a boastfully number of pull requests to DefinitelyTyped be handled wholly in a self-service manner. You can read more about why and how here. here is a handy reference showing the life-cycle of a draw request to DT :

Partial clone

You can clone the entire repository as per usual, but it’s large and includes a massive directory of type packages.
You can clone the entire repository as per usual, but it ‘s boastfully and includes a massive directory of type packages. This will take some time to clone and may be unnecessarily unwieldy .
For a more accomplishable knockoff that includes only the type packages relevant to you, you can use rotter ‘s sparse-checkout, --filter, and --depth features. This will reduce clone prison term and improve rotter performance .

⚠️ This requires minimum rotter adaptation 2.27.0, which is probable newer than the default on most machines. More complicate procedures are available in older versions, but not covered by this guidebook .

  1. git clone --sparse --filter=blob:none --depth=1
    • --sparse initializes the sparse-checkout file so the working directory starts with only the files in the root of the repository.
    • --filter=blob:none will exclude files, fetching them only as needed.
    • --depth=1 will further improve clone speed by truncating commit history, but it may cause issues as summarized here.
  2. git sparse-checkout add types/ types/ ...

Edit an existing package

When you make a PR to edit an exist package, dt-bot should @ -mention previous authors. If it does n’t, you can do so yourself in the gloss associated with the PR .

Create a new package

If you are the library author and your package is written in TypeScript, bundle the autogenerated declaration files in your box rather of publishing to Definitely Typed .
If you are adding typings for an npm software, create a directory with the like name. If the box you are adding typings for is not on npm, make sure the identify you choose for it does not conflict with the appoint of a software on npm. ( You can use npm info to check for the being of the package. )
Your software should have this structure :

File Purpose
index.d.ts This contains the typings for the package.
-tests.ts This contains sample code which tests the typings. This code does not run, but it is type-checked.
tsconfig.json This allows you to run tsc within the package.
tslint.json Enables linting.

Generate these by running npx dts-gen --dt --name --template module if you have npm ≥ 5.2.0, npm install -g dts-gen and dts-gen --dt --name --template module otherwise. See all options at dts-gen .
If you have .d.ts files besides index.d.ts, make certain that they are referenced either in index.d.ts or the tests .
decidedly Typed members routinely monitor for new PRs, though keep in mind that the number of other PRs may slow things down .
For a effective example package, see base64-js .

Removing a package

When a package bundles its own types, types should be removed from Definitely Typed to avoid confusion .
You can remove it by running npm run not-needed -- [] .

  • : This is the name of the directory to delete.
  • : A stub will be published to @types/ with this version. Should be higher than any currently published version, and should be a version of on npm.
  • : Name of npm package that replaces the Definitely Typed types. Usually this is identical to , in which case you can omit it.

Any other packages in Definitely Typed that referenced the delete package should be updated to reference the pack types. You can get this number by looking at the errors from npm run test-all. To fix the errors, add a package.json with "dependencies": { "": "x.y.z" }. For case :

   `` individual '':  true,
   `` dependencies '': {
     `` ":  




} }

When you add a package.json to dependents of , you will besides need to open a PR to add to allowedPackageJsonDependencies.txt in DefinitelyTyped-tools .
If a package was never on Definitely Typed, it does not need to be added to notNeededPackages.json .

Running tests

Test your changes by running npm test where is the name of your box .
This script uses dtslint to run the TypeScript compiler against your delirium tremens files .
once you have all your changes ready, use npm run test-all to see how your changes affect other modules .


If you are adding typings for an npm package, create a directory with the same identify. If the package you are adding typings for is not on npm, make sure the name you choose for it does not conflict with the name of a package on npm. ( You can use npm info to check for the being of the box. )
If a non-npm software conflicts with an existing npm package attempt adding -browser to the end of the name to get -browser .
There should be a -tests.ts file, which is considered your test file, along with any *.ts files it imports. If you do n’t see any test files in the module ‘s booklet, create a -tests.ts. These files are used to validate the API exported from the *.d.ts files which are shipped as @types/ .
Changes to the *.d.ts files should include a corresponding *.ts file change which shows the API being used, so that person does n’t unintentionally break code you depend on. If you do n’t see any quiz files in the module ‘s booklet, create a -tests.ts
For example, this change to a function in a .d.ts file adding a modern param to a affair :
index.d.ts :



export function twoslash ( consistency : string ) : string


export officiate twoslash ( torso : string, config ? : { version : string } ) : bowed stringed instrument

-tests.ts :

import {twoslash} from "./"

// $ExpectType string
const result = twoslash("//")



// Handle options param


const resultWithOptions = twoslash ( `` // '', { version : `` 3.7 '' } )


// When the param is faulty


// $ ExpectError


const resultWithOptions = twoslash ( `` // '', { } )

If you’re wondering where to start with trial code, the examples in the README of the module are a bang-up place to start .
You can validate your changes with npm test from the root of this repo, which takes changed files into account .
Use $ExpectType to assert that an construction is of a given type, and $ExpectError to assert that a compose error. Examples :

 // $ ExpectType void
 farad ( 1 ) ;

 // $ ExpectError
 degree fahrenheit ( `` one '' ) ;

For more details, see dtslint readme .
The linter configuration file, tslint.json should contain { "extends": "@definitelytyped/dtslint/dt.json" }, and no extra rules .
If for some cause some rule needs to be disabled, disable it for that specific line using // tslint:disable-next-line:[ruleName] — not for the wholly software, so that disabling can be reviewed. ( There are some bequest lint configs that have extra contents, but these should not happen in raw oeuvre. )
tsconfig.json should have noImplicitAny, noImplicitThis, strictNullChecks, and strictFunctionTypes set to true .
You may edit the tsconfig.json to add new test files, to add "target": "es6" ( needed for async functions ), to add to "lib", or to add the "jsx" compiler choice .


TL ; DR : esModuleInterop and allowSyntheticDefaultImports are not allowed in your tsconfig.json .

These options make it possible to write a default meaning for a CJS export, modeling the built-in interoperability between CJS and ES modules in Node and in some JS bundlers :

 // component.d.ts
 declare  class  component  {​​​​​ }​​​​​
 // CJS export, modeling `module.exports = Component` in JS
 export  =  part ;

 // index.d.ts
 // ESM default import, lone allowed under 'esModuleInterop ' or 'allowSyntheticDefaultExports '
 import  component  from  `` ./component '' ;

Since the compile-time cogency of the significance in index.d.ts is pendent upon specific compilation settings, which users of your types do not inherit, using this convention in DefinitelyTyped would force users to change their own compilation settings, which might be faulty for their runtime. rather, you must write a CJS spell for a CJS export to ensure far-flung, config-independent compatibility :

 // index.d.ts 
 // CJS import, modeling `const Component = want ( `` ./component '' ) ` in j
 import  component  = require ( `` ./component '' ) ;

normally you wo n’t need this. DefinitelyTyped ‘s package publisher creates a package.json for packages with no dependencies outside Definitely Typed. A package.json may be included to specify dependencies that are not early @types packages. Pikaday is a adept example. even if you write your own package.json, you can entirely specify dependencies ; other fields such as "description" are not allowed. You besides need to add the dependence to the list of allowed packages. This list is updated by a human, which gives us the casual to make certain that @types packages do n’t depend on malicious packages .
In the rare case that an @types package is deleted and removed in privilege of types shipped by the informant box AND you need to depend on the old, removed @types package, you can add a addiction on an @types package. Be certain to explain this when adding to the list of allowed packages indeed that the homo upholder knows what is happening .
If a file is neither tested nor referenced in index.d.ts, add it to a file named OTHER_FILES.txt. This file is a list of other files that need to be included in the typings box, one file per line .

Common mistakes

  • First, follow advice from the handbook.
  • Formatting: Use 4 spaces. Prettier is set up on this repo, so you can run npm run prettier -- --write path/to/package/**/*.ts. When using assertions, add // prettier-ignore exclusion to mark line(s) of code as excluded from formatting:
     // prettier-ignore
     const  incompleteThemeColorModes:  theme  =  {  colors:  {  modes:  {  papaya:  {  // $ ExpectError
  • function sum(nums: number[]): number: Use ReadonlyArray if a function does not write to its parameters.
  • interface Foo { new(): Foo; }:
    This defines a type of objects that are new-able. You probably want declare class Foo { constructor(); }.
  • const Class: { new(): IClass; }:
    Prefer to use a class declaration class Class { constructor(); } instead of a new-able constant.
  • getMeAT(): T:
    If a type parameter does not appear in the types of any parameters, you don’t really have a generic function, you just have a disguised type assertion.
    Prefer to use a real type assertion, e.g. getMeAT() as number.
    Example where a type parameter is acceptable: function id(value: T): T;.
    Example where it is not acceptable: function parseJson(json: string): T;.
    Exception: new Map() is OK.
  • Using the types Function and Object is almost never a good idea. In 99% of cases it’s possible to specify a more specific type. Examples are (x: number) => number for functions and { x: number, y: number } for objects. If there is no certainty at all about the type, any is the right choice, not Object. If the only known fact about the type is that it’s some object, use the type object, not Object or { [key: string]: any }.
  • var foo: string | any:
    When any is used in a union type, the resulting type is still any. So while the string portion of this type annotation may look useful, it in fact offers no additional typechecking over simply using any.
    Depending on the intention, acceptable alternatives could be any, string, or string | object.

Definition owners

TL ; DR : do not modify .github/CODEOWNERS, always modify number of the owners in the index.d.ts header

DT has the concept of “ definition Owners ” which are people who want to maintain the quality of a especial faculty ‘s types

  • Adding yourself to the list will cause you to be notified (via your GitHub username) whenever someone makes a pull request or issue about the package.
  • Your PR reviews will have a higher precedence of importance to the bot which maintains this repo.
  • The DT maintainers are putting trust in the definition owners to ensure a stable eco-system, please don’t add yourself lightly.

To Add yourself as a Definition Owner :

  • Adding your name to the end of the line, as in // Definitions by: Alice , Bob .
  • Or if there are more people, it can be multiline
     // Definitions by : Alice 
     // Bob 
     // Steve 
     // John 

once a workweek the definition Owners are synced to the charge .github/CODEOWNERS which is our source of truth .


What exactly is the relationship between this repository and the @types packages on npm?

The master branch is mechanically published to the @types scope on npm thanks to DefinitelyTyped-tools .

I’ve submitted a pull request. How long until it is merged?

It depends, but most pull requests will be merged within a workweek. Some PRs can be merged by the owners of a faculty, and they can be merged much faster. approximately :

PRs which only change the types of a module, and have corresponding tests changes will be merged much faster

puerto rico that have been approved by an author listed in the definition ‘s header are normally merged more quickly ; PRs for new definitions will take more time as they require more review from maintainers. Each PR is reviewed by a TypeScript or Definitely Typed team extremity before being merged, so please be patient as human factors may cause delays. Check the New Pull Request Status Board to see advancement as maintainers work through the open PRs .

I’d like to submit a change to a very popular project, why are they treated differently?

For changes to identical popular modules, e.g. Node/Express/Jest which have many millions of downloads each per week on npm, the requirements for contributions are a bit higher. Changes to these projects can have massive ecosystem effects, and sol we treat changes to them with a set of care. These modules require both a sign-off from a DT upholder, and enthusiastic support from the module owners. The bar for passing this can be quite high, and much PRs can go stale because it does n’t have a champion. If you’re finding that no-one is committing, test to make your PR have a smaller focus .

My PR is merged; when will the @types npm package be updated?

npm packages should update within a few minutes. If it ‘s been more than an hour, note the PR act on the Definitely Typed channel on the TypeScript Community Discord server and the current upholder will get the correct team member to investigate .

I’m writing a definition that depends on another definition. Should I use or an import?

If the module you’re referencing is an external module ( uses export ), use an import. If the module you’re referencing is an ambient module ( uses declare module, or barely declares globals ), use .

Some packages have no tslint.json, and some tsconfig.json are missing "noImplicitAny": true, "noImplicitThis": true, or "strictNullChecks": true.

then they are wrong, and we ‘ve not noticed yet. You can help by submitting a draw request to fix them .

Can I change/enforce formatting settings for modules?

No. We ‘ve explored trying to make DT ‘s code-formatting consistent before but reached an blind alley due to the high natural process on the repo. We include format settings via a .editorconfig and .prettierrc.json. These are entirely for tooling in your editor, their settings do n’t conflict and we do n’t plan on changing them. Nor do we plan on enforcing a specific stylus in the repo. We want to keep the barriers to contributions depleted .

Can I request a definition?

here are the presently requested definitions .

What about type definitions for the DOM?

If types are part of a web standard, they should be contributed to TypeScript-DOM-lib-generator so that they can become part of the default lib.dom.d.ts .

Should I add an empty namespace to a package that doesn’t export a module to use ES6 style imports?

Some packages, like chai-http, export a function .
Importing this module with an ES6 style meaning in the form import * as foo from "foo"; leads to the error :

error TS2497 : Module ‘foo ‘ resolves to a non-module entity and can not be imported using this reconstruct

This erroneousness can be suppressed by merging the function announcement with an evacuate namespace of the same list, but this practice is discouraged. This is a normally cited Stack Overflow answer regarding this matter .
It is more appropriate to import the module using the import foo = require("foo"); syntax. however, if you want to use a nonpayment significance like import foo from "foo"; you have two options :

  • you can use the --allowSyntheticDefaultImports compiler option if your module runtime supports an interop scheme for non-ECMAScript modules, i.e. if default imports work in your environment (e.g. Webpack, SystemJS, esm).
  • you can use the --esModuleInterop compiler option if you want TypeScript to take care of non-ECMAScript interop (since TypeScript 2.7).

A package uses export =, but I prefer to use default imports. Can I change export = to export default?

Like in the previous doubt, refer to using either the --allowSyntheticDefaultImports or --esModuleInterop compiler options .
Do not change the type definition if it is accurate. For an npm software, export = is accurate if node -p 'require("foo")' works to import a module, and export default is accurate if node -p 'require("foo").default' works to import a faculty .

I want to use features from very new TypeScript versions.

then you will have to add a comment to the last trace of your definition heading ( after // Definitions: ) : // Minimum TypeScript Version: X.Y. This will set the lowest minimal supported interpretation .
however, if your project needs to maintain types that are compatible with, say, 3.7 and above at the same time as types that are compatible with 3.6 or below, you will need to use the typesVersions have. You can find a detail explanation of this feature in the official TypeScript documentation .
here ‘s a short exemplar to get you started :

  1. You ‘ll have to add a package.json file to your package definition, with the following contents :

       `` individual '':  true,
       `` types '':  




    , `` typesVersions '': { `` < =3.6 '': { `` * '': [




    ] } } }
  2. Create the sub-directory mentioned in the typesVersions airfield inwardly your types directory ( ts3.6/ in this example ). ts3.6/ will support TypeScript versions 3.6 and below, so copy the existing types and tests there .
    You ‘ll need to delete the definition heading from ts3.6/index.d.ts since only the ancestor index.d.ts is supposed to have it .
  3. Set the baseUrl and typeRoots options in ts3.6/tsconfig.json to the correct paths, which should look something like this :

       `` compilerOptions '': {
         `` baseUrl '':  




    , `` typeRoots '': [




    ] } }
  4. back in the solution of the box, add the TypeScript 3.7 features you want to use. When people install the package, TypeScript 3.6 and below will start from ts3.6/index.d.ts, whereas TypeScript 3.7 and above will start from index.d.ts .
    You can look at bluebird for an exemplar .

I want to add a DOM API not present in TypeScript by default.

This may belong in TypeScript-DOM-lib-generator. See the guidelines there. If the standard is still a draft, it belongs here. Use a name beginning with dom- and include a link to the standard as the “ project ” connect in the header. When it graduates draft mode, we may remove it from Definitely Typed and deprecate the consort @types box .

How do Definitely Typed package versions relate to versions of the corresponding library?

note : The discussion in this section assumes familiarity with Semantic versioning
Each Definitely Typed package is versioned when published to npm. The DefinitelyTyped-tools ( the cock that publishes @types packages to npm ) will set the announcement software ‘s adaptation by using the major.minor version numeral listed in the first line of its index.d.ts file. For exercise, here are the inaugural few lines of Node ‘s type declarations for translation 10.12.x at the time of write :

 // Type definitions for Node.js 10.12
 // visualize : hypertext transfer protocol : //
 // Definitions by : Microsoft TypeScript 
 // Definitely Typed 
 // Alberto Schiabel 

Because 10.12 is at the end of the first course, the npm translation of the @types/node package will besides be 10.12.x. note that the first-line comment in the index.d.ts file should entirely contain the major.minor adaptation ( e.g. 10.12 ) and should not contain a patch version ( e.g. 10.12.4 ). This is because only the major and minor passing numbers are aligned between library packages and character declaration packages. The mend handout number of the type announcement package ( e.g. .0 in 10.12.0 ) is initialized to zero by Definitely Typed and is incremented each time a raw @types/node package is published to npm for the lapp major/minor version of the corresponding library .
sometimes type contract software versions and library package versions can get out of synchronize. Below are a few common reasons why, in order of how much they inconvenience users of a library. only the last case is typically baffling .

  • As noted above, the patch version of the type declaration package is unrelated to the library patch version.
    This allows Definitely Typed to safely update type declarations for the same major/minor version of a library.
  • If updating a package for new functionality, don’t forget to update the version number to line up with that version of the library.
    If users make sure versions correspond between JavaScript packages and their respective @types packages, then npm update should typically just work.
  • It’s common for type declaration package updates to lag behind library updates because it’s often library users, not maintainers, who update Definitely Typed when new library features are released.
    So there may be a lag of days, weeks, or even months before a helpful community member sends a PR to update the type declaration package for a new library release.
    If you’re impacted by this, you can be the change you want to see in the world and you can be that helpful community member!

❗ If you’re updating type declarations for a library, constantly set the major.minor version in the inaugural line of index.d.ts to match the library adaptation that you’re documenting ! ❗

If a library is updated to a new major version with breaking changes, how should I update its type declaration package?

semantic versioning requires that versions with fail changes must increment the major adaptation number. For model, a library that removes a publicly exported routine after its 3.5.8 release must bump its adaptation to 4.0.0 in its following publish. furthermore, when the library ‘s 4.0.0 exhaust is out, its Definitely Typed type resolution software should besides be updated to 4.0.0, including any pause changes to the library ‘s API .
many libraries have a bombastic install base of developers ( including maintainers of other packages using that library as a addiction ) who wo n’t move correctly away to a newly translation that has break changes, because it might be months until a upholder has time to rewrite code to adapt to the new interpretation. In the meanwhile, users of old library versions silent may want to update type declarations for older versions .
If you intend to continue updating the older version of a library ‘s type declarations, you may create a new subfolder ( e.g. /v2/ ) named for the current ( soon to be “ old ” ) version, and imitate existing files from the current version to it .
Because the root folder should always contain the type declarations for the latest ( “ new ” ) version, you ‘ll need to make a few changes to the files in your old-version subdirectory to ensure that proportional path references point to the subdirectory, not the beginning .

  1. Update the relative paths in tsconfig.json as well as tslint.json.
  2. Add path mapping rules to ensure that tests are running against the intended version.

For case, the history library introduced breaking changes between interpretation 2.x and 3.x. Because many users even consumed the older 2.x translation, a upholder who wanted to update the type declarations for this library to 3.x added a v2 booklet inside the history repository that contains type declarations for the older version. At the time of writing, the history v2 tsconfig.json looks roughly like :

   `` compilerOptions '': {
     `` baseUrl '':  




, `` typeRoots '': [




], `` paths '': { `` history '': [




] } }, `` files '': [








] }

If there are other packages in Definitely Typed that are uncongenial with the new version, you will need to add way mappings to the old version. You will besides need to do this recursively for packages depending on the old interpretation .
For exercise, react-router depends on history@2, so react-router tsconfig.json has a path map to "history": [ "history/v2" ]. transitively, react-router-bootstrap ( which depends on react-router ) besides needed to add the same path map ( "history": [ "history/v2" ] ) in its tsconfig.json until its react-router addiction was updated to the latest translation .
besides, /// will not work with path map, so dependencies must use import .

How do I write definitions for packages that can be used globally and as a module?

The TypeScript handbook contains excellent general information about writing definitions, and besides this example definition file which shows how to create a definition using ES6-style faculty syntax, while besides specifying objects made available to the global oscilloscope. This technique is demonstrated practically in the definition for big.js, which is a library that can be loaded globally via script tag on a network page, or imported via necessitate or ES6-style imports .
To test how your definition can be used both when referenced globally or as an import module, create a test booklet, and place two screen files in there. Name one YourLibraryName-global.test.ts and the other YourLibraryName-module.test.ts. The ball-shaped test file should exercise the definition according to how it would be used in a handwriting loaded on a world wide web page where the library is available on the ball-shaped setting – in this scenario you should not specify an significance statement. The module test file should exercise the definition according to how it would be used when imported ( including the import statement ( s ) ). If you specify a files place in your tsconfig.json file, be certain to include both test files. A practical example of this is besides available on the big.js definition .
Please note that it is not required to amply exercise the definition in each test file – it is sufficient to test only the globally-accessible elements on the ball-shaped test file and in full exercise the definition in the module test file, or frailty versa .

What about scoped packages?

Types for a scoped package @foo/bar should go in types/foo__bar. Note the double underline .
When dts-gen is used to scaffold a scoped package, the paths property has to be manually adapted in the generate tsconfig.json to correctly reference the scoped package :

   `` paths '': {
     `` @ foo/* '': [ 




] } }

The file history in GitHub looks incomplete.

GitHub does n’t support file history for rename files. Use git log --follow rather .


This project is licensed under the MIT license .
Copyrights on the definition files are respective of each contributor listed at the beginning of each definition file .

reservoir : https://coinselected
Category : coin 4u

Leave a Reply

Your email address will not be published.