graphql-scalars

  • Version 1.24.0
  • Published
  • 579 kB
  • 1 dependency
  • MIT license

Install

npm i graphql-scalars
yarn add graphql-scalars
pnpm add graphql-scalars

Overview

A collection of scalar types not included in base GraphQL.

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable AccountNumberDefinition

const AccountNumberDefinition: string;

    variable AccountNumberResolver

    const AccountNumberResolver: GraphQLScalarType<string, string>;

      variable BigIntResolver

      const BigIntResolver: GraphQLScalarType<number | bigint, string | number | bigint>;

        variable BigIntTypeDefinition

        const BigIntTypeDefinition: string;

          variable ByteResolver

          const ByteResolver: GraphQLScalarType<any, Buffer<ArrayBufferLike>>;

            variable ByteTypeDefinition

            const ByteTypeDefinition: string;

              variable CountryCodeDefinition

              const CountryCodeDefinition: string;

                variable CountryCodeResolver

                const CountryCodeResolver: GraphQLScalarType<string, string>;

                  variable CountryNameResolver

                  const CountryNameResolver: GraphQLScalarType<
                  | 'Afghanistan'
                  | 'Ã…land Islands'
                  | 'Albania'
                  | 'Algeria'
                  | 'American Samoa'
                  | 'Andorra'
                  | 'Angola'
                  | 'Anguilla'
                  | 'Antarctica'
                  | 'Antigua and Barbuda'
                  | 'Argentina'
                  | 'Armenia'
                  | 'Aruba'
                  | 'Australia'
                  | 'Austria'
                  | 'Azerbaijan'
                  | 'Bahamas'
                  | 'Bahrain'
                  | 'Bangladesh'
                  | 'Barbados'
                  | 'Belarus'
                  | 'Belgium'
                  | 'Belize'
                  | 'Benin'
                  | 'Bermuda'
                  | 'Bhutan'
                  | 'Bolivia, Plurinational State of'
                  | 'Bonaire, Sint Eustatius and Saba'
                  | 'Bosnia and Herzegovina'
                  | 'Botswana'
                  | 'Bouvet Island'
                  | 'Brazil'
                  | 'British Indian Ocean Territory'
                  | 'Brunei Darussalam'
                  | 'Bulgaria'
                  | 'Burkina Faso'
                  | 'Burundi'
                  | 'Cabo Verde'
                  | 'Cambodia'
                  | 'Cameroon'
                  | 'Canada'
                  | 'Cayman Islands'
                  | 'Central African Republic'
                  | 'Chad'
                  | 'Chile'
                  | 'China'
                  | 'Christmas Island'
                  | 'Cocos (Keeling) Islands'
                  | 'Colombia'
                  | 'Comoros'
                  | 'Congo, Republic of the'
                  | 'Congo, Democratic Republic of the'
                  | 'Cook Islands'
                  | 'Costa Rica'
                  | "Côte d'Ivoire"
                  | 'Croatia'
                  | 'Cuba'
                  | 'Curaçao'
                  | 'Cyprus'
                  | 'Czechia'
                  | 'Denmark'
                  | 'Djibouti'
                  | 'Dominica'
                  | 'Dominican Republic'
                  | 'Ecuador'
                  | 'Egypt'
                  | 'El Salvador'
                  | 'Equatorial Guinea'
                  | 'Eritrea'
                  | 'Estonia'
                  | 'Eswatini'
                  | 'Ethiopia'
                  | 'Falkland Islands (Malvinas)'
                  | 'Faroe Islands'
                  | 'Fiji'
                  | 'Finland'
                  | 'France'
                  | 'French Guiana'
                  | 'French Polynesia'
                  | 'French Southern Territories'
                  | 'Gabon'
                  | 'Gambia'
                  | 'Georgia'
                  | 'Germany'
                  | 'Ghana'
                  | 'Gibraltar'
                  | 'Greece'
                  | 'Greenland'
                  | 'Grenada'
                  | 'Guadeloupe'
                  | 'Guam'
                  | 'Guatemala'
                  | 'Guernsey'
                  | 'Guinea'
                  | 'Guinea-Bissau'
                  | 'Guyana'
                  | 'Haiti'
                  | 'Heard Island and McDonald Islands'
                  | 'Holy See'
                  | 'Honduras'
                  | 'Hong Kong'
                  | 'Hungary'
                  | 'Iceland'
                  | 'India'
                  | 'Indonesia'
                  | 'Iran, Islamic Republic of'
                  | 'Iraq'
                  | 'Ireland'
                  | 'Isle of Man'
                  | 'Israel'
                  | 'Italy'
                  | 'Jamaica'
                  | 'Japan'
                  | 'Jersey'
                  | 'Jordan'
                  | 'Kazakhstan'
                  | 'Kenya'
                  | 'Kiribati'
                  | "Korea, Democratic People's Republic of"
                  | 'Korea, Republic of'
                  | 'Kuwait'
                  | 'Kyrgyzstan'
                  | "Lao People's Democratic Republic"
                  | 'Latvia'
                  | 'Lebanon'
                  | 'Lesotho'
                  | 'Liberia'
                  | 'Libya'
                  | 'Liechtenstein'
                  | 'Lithuania'
                  | 'Luxembourg'
                  | 'Macao'
                  | 'Madagascar'
                  | 'Malawi'
                  | 'Malaysia'
                  | 'Maldives'
                  | 'Mali'
                  | 'Malta'
                  | 'Marshall Islands'
                  | 'Martinique'
                  | 'Mauritania'
                  | 'Mauritius'
                  | 'Mayotte'
                  | 'Mexico'
                  | 'Micronesia, Federated States of'
                  | 'Moldova, Republic of'
                  | 'Monaco'
                  | 'Mongolia'
                  | 'Montenegro'
                  | 'Montserrat'
                  | 'Morocco'
                  | 'Mozambique'
                  | 'Myanmar'
                  | 'Namibia'
                  | 'Nauru'
                  | 'Nepal'
                  | 'Netherlands, Kingdom of the'
                  | 'New Caledonia'
                  | 'New Zealand'
                  | 'Nicaragua'
                  | 'Niger'
                  | 'Nigeria'
                  | 'Niue'
                  | 'Norfolk Island'
                  | 'North Macedonia'
                  | 'Northern Mariana Islands'
                  | 'Norway'
                  | 'Oman'
                  | 'Pakistan'
                  | 'Palau'
                  | 'Palestine, State of'
                  | 'Panama'
                  | 'Papua New Guinea'
                  | 'Paraguay'
                  | 'Peru'
                  | 'Philippines'
                  | 'Pitcairn'
                  | 'Poland'
                  | 'Portugal'
                  | 'Puerto Rico'
                  | 'Qatar'
                  | 'Réunion'
                  | 'Romania'
                  | 'Russian Federation'
                  | 'Rwanda'
                  | 'Saint Barthélemy'
                  | 'Saint Helena, Ascension and Tristan da Cunha'
                  | 'Saint Kitts and Nevis'
                  | 'Saint Lucia'
                  | 'Saint Martin (French part)'
                  | 'Saint Pierre and Miquelon'
                  | 'Saint Vincent and the Grenadines'
                  | 'Samoa'
                  | 'San Marino'
                  | 'São Tomé and Príncipe'
                  | 'Saudi Arabia'
                  | 'Senegal'
                  | 'Serbia'
                  | 'Seychelles'
                  | 'Sierra Leone'
                  | 'Singapore'
                  | 'Sint Maarten (Dutch part)'
                  | 'Slovakia'
                  | 'Slovenia'
                  | 'Solomon Islands'
                  | 'Somalia'
                  | 'South Africa'
                  | 'South Georgia and the South Sandwich Islands'
                  | 'South Sudan'
                  | 'Spain'
                  | 'Sri Lanka'
                  | 'Sudan'
                  | 'Suriname'
                  | 'Svalbard and Jan Mayen'
                  | 'Sweden'
                  | 'Switzerland'
                  | 'Syrian Arab Republic'
                  | 'Taiwan, Province of China'
                  | 'Tajikistan'
                  | 'Tanzania, United Republic of'
                  | 'Thailand'
                  | 'Timor-Leste'
                  | 'Togo'
                  | 'Tokelau'
                  | 'Tonga'
                  | 'Trinidad and Tobago'
                  | 'Tunisia'
                  | 'Türkiye'
                  | 'Turkmenistan'
                  | 'Turks and Caicos Islands'
                  | 'Tuvalu'
                  | 'Uganda'
                  | 'Ukraine'
                  | 'United Arab Emirates'
                  | 'United Kingdom of Great Britain and Northern Ireland'
                  | 'United States of America'
                  | 'United States Minor Outlying Islands'
                  | 'Uruguay'
                  | 'Uzbekistan'
                  | 'Vanuatu'
                  | 'Venezuela, Bolivarian Republic of'
                  | 'Viet Nam'
                  | 'Virgin Islands (British)'
                  | 'Virgin Islands (U.S.)'
                  | 'Wallis and Futuna'
                  | 'Western Sahara'
                  | 'Yemen'
                  | 'Zambia'
                  | 'Zimbabwe',
                  | 'Afghanistan'
                  | 'Ã…land Islands'
                  | 'Albania'
                  | 'Algeria'
                  | 'American Samoa'
                  | 'Andorra'
                  | 'Angola'
                  | 'Anguilla'
                  | 'Antarctica'
                  | 'Antigua and Barbuda'
                  | 'Argentina'
                  | 'Armenia'
                  | 'Aruba'
                  | 'Australia'
                  | 'Austria'
                  | 'Azerbaijan'
                  | 'Bahamas'
                  | 'Bahrain'
                  | 'Bangladesh'
                  | 'Barbados'
                  | 'Belarus'
                  | 'Belgium'
                  | 'Belize'
                  | 'Benin'
                  | 'Bermuda'
                  | 'Bhutan'
                  | 'Bolivia, Plurinational State of'
                  | 'Bonaire, Sint Eustatius and Saba'
                  | 'Bosnia and Herzegovina'
                  | 'Botswana'
                  | 'Bouvet Island'
                  | 'Brazil'
                  | 'British Indian Ocean Territory'
                  | 'Brunei Darussalam'
                  | 'Bulgaria'
                  | 'Burkina Faso'
                  | 'Burundi'
                  | 'Cabo Verde'
                  | 'Cambodia'
                  | 'Cameroon'
                  | 'Canada'
                  | 'Cayman Islands'
                  | 'Central African Republic'
                  | 'Chad'
                  | 'Chile'
                  | 'China'
                  | 'Christmas Island'
                  | 'Cocos (Keeling) Islands'
                  | 'Colombia'
                  | 'Comoros'
                  | 'Congo, Republic of the'
                  | 'Congo, Democratic Republic of the'
                  | 'Cook Islands'
                  | 'Costa Rica'
                  | "Côte d'Ivoire"
                  | 'Croatia'
                  | 'Cuba'
                  | 'Curaçao'
                  | 'Cyprus'
                  | 'Czechia'
                  | 'Denmark'
                  | 'Djibouti'
                  | 'Dominica'
                  | 'Dominican Republic'
                  | 'Ecuador'
                  | 'Egypt'
                  | 'El Salvador'
                  | 'Equatorial Guinea'
                  | 'Eritrea'
                  | 'Estonia'
                  | 'Eswatini'
                  | 'Ethiopia'
                  | 'Falkland Islands (Malvinas)'
                  | 'Faroe Islands'
                  | 'Fiji'
                  | 'Finland'
                  | 'France'
                  | 'French Guiana'
                  | 'French Polynesia'
                  | 'French Southern Territories'
                  | 'Gabon'
                  | 'Gambia'
                  | 'Georgia'
                  | 'Germany'
                  | 'Ghana'
                  | 'Gibraltar'
                  | 'Greece'
                  | 'Greenland'
                  | 'Grenada'
                  | 'Guadeloupe'
                  | 'Guam'
                  | 'Guatemala'
                  | 'Guernsey'
                  | 'Guinea'
                  | 'Guinea-Bissau'
                  | 'Guyana'
                  | 'Haiti'
                  | 'Heard Island and McDonald Islands'
                  | 'Holy See'
                  | 'Honduras'
                  | 'Hong Kong'
                  | 'Hungary'
                  | 'Iceland'
                  | 'India'
                  | 'Indonesia'
                  | 'Iran, Islamic Republic of'
                  | 'Iraq'
                  | 'Ireland'
                  | 'Isle of Man'
                  | 'Israel'
                  | 'Italy'
                  | 'Jamaica'
                  | 'Japan'
                  | 'Jersey'
                  | 'Jordan'
                  | 'Kazakhstan'
                  | 'Kenya'
                  | 'Kiribati'
                  | "Korea, Democratic People's Republic of"
                  | 'Korea, Republic of'
                  | 'Kuwait'
                  | 'Kyrgyzstan'
                  | "Lao People's Democratic Republic"
                  | 'Latvia'
                  | 'Lebanon'
                  | 'Lesotho'
                  | 'Liberia'
                  | 'Libya'
                  | 'Liechtenstein'
                  | 'Lithuania'
                  | 'Luxembourg'
                  | 'Macao'
                  | 'Madagascar'
                  | 'Malawi'
                  | 'Malaysia'
                  | 'Maldives'
                  | 'Mali'
                  | 'Malta'
                  | 'Marshall Islands'
                  | 'Martinique'
                  | 'Mauritania'
                  | 'Mauritius'
                  | 'Mayotte'
                  | 'Mexico'
                  | 'Micronesia, Federated States of'
                  | 'Moldova, Republic of'
                  | 'Monaco'
                  | 'Mongolia'
                  | 'Montenegro'
                  | 'Montserrat'
                  | 'Morocco'
                  | 'Mozambique'
                  | 'Myanmar'
                  | 'Namibia'
                  | 'Nauru'
                  | 'Nepal'
                  | 'Netherlands, Kingdom of the'
                  | 'New Caledonia'
                  | 'New Zealand'
                  | 'Nicaragua'
                  | 'Niger'
                  | 'Nigeria'
                  | 'Niue'
                  | 'Norfolk Island'
                  | 'North Macedonia'
                  | 'Northern Mariana Islands'
                  | 'Norway'
                  | 'Oman'
                  | 'Pakistan'
                  | 'Palau'
                  | 'Palestine, State of'
                  | 'Panama'
                  | 'Papua New Guinea'
                  | 'Paraguay'
                  | 'Peru'
                  | 'Philippines'
                  | 'Pitcairn'
                  | 'Poland'
                  | 'Portugal'
                  | 'Puerto Rico'
                  | 'Qatar'
                  | 'Réunion'
                  | 'Romania'
                  | 'Russian Federation'
                  | 'Rwanda'
                  | 'Saint Barthélemy'
                  | 'Saint Helena, Ascension and Tristan da Cunha'
                  | 'Saint Kitts and Nevis'
                  | 'Saint Lucia'
                  | 'Saint Martin (French part)'
                  | 'Saint Pierre and Miquelon'
                  | 'Saint Vincent and the Grenadines'
                  | 'Samoa'
                  | 'San Marino'
                  | 'São Tomé and Príncipe'
                  | 'Saudi Arabia'
                  | 'Senegal'
                  | 'Serbia'
                  | 'Seychelles'
                  | 'Sierra Leone'
                  | 'Singapore'
                  | 'Sint Maarten (Dutch part)'
                  | 'Slovakia'
                  | 'Slovenia'
                  | 'Solomon Islands'
                  | 'Somalia'
                  | 'South Africa'
                  | 'South Georgia and the South Sandwich Islands'
                  | 'South Sudan'
                  | 'Spain'
                  | 'Sri Lanka'
                  | 'Sudan'
                  | 'Suriname'
                  | 'Svalbard and Jan Mayen'
                  | 'Sweden'
                  | 'Switzerland'
                  | 'Syrian Arab Republic'
                  | 'Taiwan, Province of China'
                  | 'Tajikistan'
                  | 'Tanzania, United Republic of'
                  | 'Thailand'
                  | 'Timor-Leste'
                  | 'Togo'
                  | 'Tokelau'
                  | 'Tonga'
                  | 'Trinidad and Tobago'
                  | 'Tunisia'
                  | 'Türkiye'
                  | 'Turkmenistan'
                  | 'Turks and Caicos Islands'
                  | 'Tuvalu'
                  | 'Uganda'
                  | 'Ukraine'
                  | 'United Arab Emirates'
                  | 'United Kingdom of Great Britain and Northern Ireland'
                  | 'United States of America'
                  | 'United States Minor Outlying Islands'
                  | 'Uruguay'
                  | 'Uzbekistan'
                  | 'Vanuatu'
                  | 'Venezuela, Bolivarian Republic of'
                  | 'Viet Nam'
                  | 'Virgin Islands (British)'
                  | 'Virgin Islands (U.S.)'
                  | 'Wallis and Futuna'
                  | 'Western Sahara'
                  | 'Yemen'
                  | 'Zambia'
                  | 'Zimbabwe'
                  >;

                    variable CountryNameTypeDefinition

                    const CountryNameTypeDefinition: string;

                      variable CuidDefinition

                      const CuidDefinition: string;

                        variable CuidResolver

                        const CuidResolver: GraphQLScalarType<string, string>;

                          variable CurrencyDefinition

                          const CurrencyDefinition: string;

                            variable CurrencyResolver

                            const CurrencyResolver: GraphQLScalarType<string, string>;

                              variable DateResolver

                              const DateResolver: GraphQLScalarType<Date, string>;
                              • An RFC 3339 compliant date scalar.

                                Input: This scalar takes an RFC 3339 date string as input and parses it to a javascript Date.

                                Output: This scalar serializes javascript Dates and RFC 3339 date strings to RFC 3339 date strings.

                              variable DateTimeISOResolver

                              const DateTimeISOResolver: GraphQLScalarType<Date, string>;

                                variable DateTimeISOTypeDefinition

                                const DateTimeISOTypeDefinition: string;

                                  variable DateTimeResolver

                                  const DateTimeResolver: GraphQLScalarType<Date, Date>;
                                  • An RFC 3339 compliant date-time scalar.

                                    Input: This scalar takes an RFC 3339 date-time string as input and parses it to a javascript Date.

                                    Output: This scalar serializes javascript Dates, RFC 3339 date-time strings and unix timestamps to RFC 3339 UTC date-time strings.

                                  variable DateTimeTypeDefinition

                                  const DateTimeTypeDefinition: string;

                                    variable DateTypeDefinition

                                    const DateTypeDefinition: string;

                                      variable DeweyDecimalDefinition

                                      const DeweyDecimalDefinition: string;

                                        variable DIDDefinition

                                        const DIDDefinition: string;

                                          variable DIDResolver

                                          const DIDResolver: GraphQLScalarType<string, string>;

                                            variable DurationResolver

                                            const DurationResolver: GraphQLScalarType<string, string>;

                                              variable DurationTypeDefinition

                                              const DurationTypeDefinition: string;

                                                variable EmailAddressResolver

                                                const EmailAddressResolver: GraphQLScalarType<string, string>;

                                                  variable EmailAddressTypeDefinition

                                                  const EmailAddressTypeDefinition: string;

                                                    variable GeoJSONResolver

                                                    const GeoJSONResolver: GraphQLScalarType<GeoJSONObject, GeoJSONObject>;

                                                      variable GeoJSONTypeDefinition

                                                      const GeoJSONTypeDefinition: string;

                                                        variable GraphQLAccountNumber

                                                        const GraphQLAccountNumber: GraphQLScalarType<string, string>;

                                                          variable GraphQLBigInt

                                                          const GraphQLBigInt: GraphQLScalarType<number | bigint, string | number | bigint>;

                                                            variable GraphQLByte

                                                            const GraphQLByte: GraphQLScalarType<any, Buffer<ArrayBufferLike>>;

                                                              variable GraphQLCountryCode

                                                              const GraphQLCountryCode: GraphQLScalarType<string, string>;

                                                                variable GraphQLCountryName

                                                                const GraphQLCountryName: GraphQLScalarType<
                                                                | 'Afghanistan'
                                                                | 'Ã…land Islands'
                                                                | 'Albania'
                                                                | 'Algeria'
                                                                | 'American Samoa'
                                                                | 'Andorra'
                                                                | 'Angola'
                                                                | 'Anguilla'
                                                                | 'Antarctica'
                                                                | 'Antigua and Barbuda'
                                                                | 'Argentina'
                                                                | 'Armenia'
                                                                | 'Aruba'
                                                                | 'Australia'
                                                                | 'Austria'
                                                                | 'Azerbaijan'
                                                                | 'Bahamas'
                                                                | 'Bahrain'
                                                                | 'Bangladesh'
                                                                | 'Barbados'
                                                                | 'Belarus'
                                                                | 'Belgium'
                                                                | 'Belize'
                                                                | 'Benin'
                                                                | 'Bermuda'
                                                                | 'Bhutan'
                                                                | 'Bolivia, Plurinational State of'
                                                                | 'Bonaire, Sint Eustatius and Saba'
                                                                | 'Bosnia and Herzegovina'
                                                                | 'Botswana'
                                                                | 'Bouvet Island'
                                                                | 'Brazil'
                                                                | 'British Indian Ocean Territory'
                                                                | 'Brunei Darussalam'
                                                                | 'Bulgaria'
                                                                | 'Burkina Faso'
                                                                | 'Burundi'
                                                                | 'Cabo Verde'
                                                                | 'Cambodia'
                                                                | 'Cameroon'
                                                                | 'Canada'
                                                                | 'Cayman Islands'
                                                                | 'Central African Republic'
                                                                | 'Chad'
                                                                | 'Chile'
                                                                | 'China'
                                                                | 'Christmas Island'
                                                                | 'Cocos (Keeling) Islands'
                                                                | 'Colombia'
                                                                | 'Comoros'
                                                                | 'Congo, Republic of the'
                                                                | 'Congo, Democratic Republic of the'
                                                                | 'Cook Islands'
                                                                | 'Costa Rica'
                                                                | "Côte d'Ivoire"
                                                                | 'Croatia'
                                                                | 'Cuba'
                                                                | 'Curaçao'
                                                                | 'Cyprus'
                                                                | 'Czechia'
                                                                | 'Denmark'
                                                                | 'Djibouti'
                                                                | 'Dominica'
                                                                | 'Dominican Republic'
                                                                | 'Ecuador'
                                                                | 'Egypt'
                                                                | 'El Salvador'
                                                                | 'Equatorial Guinea'
                                                                | 'Eritrea'
                                                                | 'Estonia'
                                                                | 'Eswatini'
                                                                | 'Ethiopia'
                                                                | 'Falkland Islands (Malvinas)'
                                                                | 'Faroe Islands'
                                                                | 'Fiji'
                                                                | 'Finland'
                                                                | 'France'
                                                                | 'French Guiana'
                                                                | 'French Polynesia'
                                                                | 'French Southern Territories'
                                                                | 'Gabon'
                                                                | 'Gambia'
                                                                | 'Georgia'
                                                                | 'Germany'
                                                                | 'Ghana'
                                                                | 'Gibraltar'
                                                                | 'Greece'
                                                                | 'Greenland'
                                                                | 'Grenada'
                                                                | 'Guadeloupe'
                                                                | 'Guam'
                                                                | 'Guatemala'
                                                                | 'Guernsey'
                                                                | 'Guinea'
                                                                | 'Guinea-Bissau'
                                                                | 'Guyana'
                                                                | 'Haiti'
                                                                | 'Heard Island and McDonald Islands'
                                                                | 'Holy See'
                                                                | 'Honduras'
                                                                | 'Hong Kong'
                                                                | 'Hungary'
                                                                | 'Iceland'
                                                                | 'India'
                                                                | 'Indonesia'
                                                                | 'Iran, Islamic Republic of'
                                                                | 'Iraq'
                                                                | 'Ireland'
                                                                | 'Isle of Man'
                                                                | 'Israel'
                                                                | 'Italy'
                                                                | 'Jamaica'
                                                                | 'Japan'
                                                                | 'Jersey'
                                                                | 'Jordan'
                                                                | 'Kazakhstan'
                                                                | 'Kenya'
                                                                | 'Kiribati'
                                                                | "Korea, Democratic People's Republic of"
                                                                | 'Korea, Republic of'
                                                                | 'Kuwait'
                                                                | 'Kyrgyzstan'
                                                                | "Lao People's Democratic Republic"
                                                                | 'Latvia'
                                                                | 'Lebanon'
                                                                | 'Lesotho'
                                                                | 'Liberia'
                                                                | 'Libya'
                                                                | 'Liechtenstein'
                                                                | 'Lithuania'
                                                                | 'Luxembourg'
                                                                | 'Macao'
                                                                | 'Madagascar'
                                                                | 'Malawi'
                                                                | 'Malaysia'
                                                                | 'Maldives'
                                                                | 'Mali'
                                                                | 'Malta'
                                                                | 'Marshall Islands'
                                                                | 'Martinique'
                                                                | 'Mauritania'
                                                                | 'Mauritius'
                                                                | 'Mayotte'
                                                                | 'Mexico'
                                                                | 'Micronesia, Federated States of'
                                                                | 'Moldova, Republic of'
                                                                | 'Monaco'
                                                                | 'Mongolia'
                                                                | 'Montenegro'
                                                                | 'Montserrat'
                                                                | 'Morocco'
                                                                | 'Mozambique'
                                                                | 'Myanmar'
                                                                | 'Namibia'
                                                                | 'Nauru'
                                                                | 'Nepal'
                                                                | 'Netherlands, Kingdom of the'
                                                                | 'New Caledonia'
                                                                | 'New Zealand'
                                                                | 'Nicaragua'
                                                                | 'Niger'
                                                                | 'Nigeria'
                                                                | 'Niue'
                                                                | 'Norfolk Island'
                                                                | 'North Macedonia'
                                                                | 'Northern Mariana Islands'
                                                                | 'Norway'
                                                                | 'Oman'
                                                                | 'Pakistan'
                                                                | 'Palau'
                                                                | 'Palestine, State of'
                                                                | 'Panama'
                                                                | 'Papua New Guinea'
                                                                | 'Paraguay'
                                                                | 'Peru'
                                                                | 'Philippines'
                                                                | 'Pitcairn'
                                                                | 'Poland'
                                                                | 'Portugal'
                                                                | 'Puerto Rico'
                                                                | 'Qatar'
                                                                | 'Réunion'
                                                                | 'Romania'
                                                                | 'Russian Federation'
                                                                | 'Rwanda'
                                                                | 'Saint Barthélemy'
                                                                | 'Saint Helena, Ascension and Tristan da Cunha'
                                                                | 'Saint Kitts and Nevis'
                                                                | 'Saint Lucia'
                                                                | 'Saint Martin (French part)'
                                                                | 'Saint Pierre and Miquelon'
                                                                | 'Saint Vincent and the Grenadines'
                                                                | 'Samoa'
                                                                | 'San Marino'
                                                                | 'São Tomé and Príncipe'
                                                                | 'Saudi Arabia'
                                                                | 'Senegal'
                                                                | 'Serbia'
                                                                | 'Seychelles'
                                                                | 'Sierra Leone'
                                                                | 'Singapore'
                                                                | 'Sint Maarten (Dutch part)'
                                                                | 'Slovakia'
                                                                | 'Slovenia'
                                                                | 'Solomon Islands'
                                                                | 'Somalia'
                                                                | 'South Africa'
                                                                | 'South Georgia and the South Sandwich Islands'
                                                                | 'South Sudan'
                                                                | 'Spain'
                                                                | 'Sri Lanka'
                                                                | 'Sudan'
                                                                | 'Suriname'
                                                                | 'Svalbard and Jan Mayen'
                                                                | 'Sweden'
                                                                | 'Switzerland'
                                                                | 'Syrian Arab Republic'
                                                                | 'Taiwan, Province of China'
                                                                | 'Tajikistan'
                                                                | 'Tanzania, United Republic of'
                                                                | 'Thailand'
                                                                | 'Timor-Leste'
                                                                | 'Togo'
                                                                | 'Tokelau'
                                                                | 'Tonga'
                                                                | 'Trinidad and Tobago'
                                                                | 'Tunisia'
                                                                | 'Türkiye'
                                                                | 'Turkmenistan'
                                                                | 'Turks and Caicos Islands'
                                                                | 'Tuvalu'
                                                                | 'Uganda'
                                                                | 'Ukraine'
                                                                | 'United Arab Emirates'
                                                                | 'United Kingdom of Great Britain and Northern Ireland'
                                                                | 'United States of America'
                                                                | 'United States Minor Outlying Islands'
                                                                | 'Uruguay'
                                                                | 'Uzbekistan'
                                                                | 'Vanuatu'
                                                                | 'Venezuela, Bolivarian Republic of'
                                                                | 'Viet Nam'
                                                                | 'Virgin Islands (British)'
                                                                | 'Virgin Islands (U.S.)'
                                                                | 'Wallis and Futuna'
                                                                | 'Western Sahara'
                                                                | 'Yemen'
                                                                | 'Zambia'
                                                                | 'Zimbabwe',
                                                                | 'Afghanistan'
                                                                | 'Ã…land Islands'
                                                                | 'Albania'
                                                                | 'Algeria'
                                                                | 'American Samoa'
                                                                | 'Andorra'
                                                                | 'Angola'
                                                                | 'Anguilla'
                                                                | 'Antarctica'
                                                                | 'Antigua and Barbuda'
                                                                | 'Argentina'
                                                                | 'Armenia'
                                                                | 'Aruba'
                                                                | 'Australia'
                                                                | 'Austria'
                                                                | 'Azerbaijan'
                                                                | 'Bahamas'
                                                                | 'Bahrain'
                                                                | 'Bangladesh'
                                                                | 'Barbados'
                                                                | 'Belarus'
                                                                | 'Belgium'
                                                                | 'Belize'
                                                                | 'Benin'
                                                                | 'Bermuda'
                                                                | 'Bhutan'
                                                                | 'Bolivia, Plurinational State of'
                                                                | 'Bonaire, Sint Eustatius and Saba'
                                                                | 'Bosnia and Herzegovina'
                                                                | 'Botswana'
                                                                | 'Bouvet Island'
                                                                | 'Brazil'
                                                                | 'British Indian Ocean Territory'
                                                                | 'Brunei Darussalam'
                                                                | 'Bulgaria'
                                                                | 'Burkina Faso'
                                                                | 'Burundi'
                                                                | 'Cabo Verde'
                                                                | 'Cambodia'
                                                                | 'Cameroon'
                                                                | 'Canada'
                                                                | 'Cayman Islands'
                                                                | 'Central African Republic'
                                                                | 'Chad'
                                                                | 'Chile'
                                                                | 'China'
                                                                | 'Christmas Island'
                                                                | 'Cocos (Keeling) Islands'
                                                                | 'Colombia'
                                                                | 'Comoros'
                                                                | 'Congo, Republic of the'
                                                                | 'Congo, Democratic Republic of the'
                                                                | 'Cook Islands'
                                                                | 'Costa Rica'
                                                                | "Côte d'Ivoire"
                                                                | 'Croatia'
                                                                | 'Cuba'
                                                                | 'Curaçao'
                                                                | 'Cyprus'
                                                                | 'Czechia'
                                                                | 'Denmark'
                                                                | 'Djibouti'
                                                                | 'Dominica'
                                                                | 'Dominican Republic'
                                                                | 'Ecuador'
                                                                | 'Egypt'
                                                                | 'El Salvador'
                                                                | 'Equatorial Guinea'
                                                                | 'Eritrea'
                                                                | 'Estonia'
                                                                | 'Eswatini'
                                                                | 'Ethiopia'
                                                                | 'Falkland Islands (Malvinas)'
                                                                | 'Faroe Islands'
                                                                | 'Fiji'
                                                                | 'Finland'
                                                                | 'France'
                                                                | 'French Guiana'
                                                                | 'French Polynesia'
                                                                | 'French Southern Territories'
                                                                | 'Gabon'
                                                                | 'Gambia'
                                                                | 'Georgia'
                                                                | 'Germany'
                                                                | 'Ghana'
                                                                | 'Gibraltar'
                                                                | 'Greece'
                                                                | 'Greenland'
                                                                | 'Grenada'
                                                                | 'Guadeloupe'
                                                                | 'Guam'
                                                                | 'Guatemala'
                                                                | 'Guernsey'
                                                                | 'Guinea'
                                                                | 'Guinea-Bissau'
                                                                | 'Guyana'
                                                                | 'Haiti'
                                                                | 'Heard Island and McDonald Islands'
                                                                | 'Holy See'
                                                                | 'Honduras'
                                                                | 'Hong Kong'
                                                                | 'Hungary'
                                                                | 'Iceland'
                                                                | 'India'
                                                                | 'Indonesia'
                                                                | 'Iran, Islamic Republic of'
                                                                | 'Iraq'
                                                                | 'Ireland'
                                                                | 'Isle of Man'
                                                                | 'Israel'
                                                                | 'Italy'
                                                                | 'Jamaica'
                                                                | 'Japan'
                                                                | 'Jersey'
                                                                | 'Jordan'
                                                                | 'Kazakhstan'
                                                                | 'Kenya'
                                                                | 'Kiribati'
                                                                | "Korea, Democratic People's Republic of"
                                                                | 'Korea, Republic of'
                                                                | 'Kuwait'
                                                                | 'Kyrgyzstan'
                                                                | "Lao People's Democratic Republic"
                                                                | 'Latvia'
                                                                | 'Lebanon'
                                                                | 'Lesotho'
                                                                | 'Liberia'
                                                                | 'Libya'
                                                                | 'Liechtenstein'
                                                                | 'Lithuania'
                                                                | 'Luxembourg'
                                                                | 'Macao'
                                                                | 'Madagascar'
                                                                | 'Malawi'
                                                                | 'Malaysia'
                                                                | 'Maldives'
                                                                | 'Mali'
                                                                | 'Malta'
                                                                | 'Marshall Islands'
                                                                | 'Martinique'
                                                                | 'Mauritania'
                                                                | 'Mauritius'
                                                                | 'Mayotte'
                                                                | 'Mexico'
                                                                | 'Micronesia, Federated States of'
                                                                | 'Moldova, Republic of'
                                                                | 'Monaco'
                                                                | 'Mongolia'
                                                                | 'Montenegro'
                                                                | 'Montserrat'
                                                                | 'Morocco'
                                                                | 'Mozambique'
                                                                | 'Myanmar'
                                                                | 'Namibia'
                                                                | 'Nauru'
                                                                | 'Nepal'
                                                                | 'Netherlands, Kingdom of the'
                                                                | 'New Caledonia'
                                                                | 'New Zealand'
                                                                | 'Nicaragua'
                                                                | 'Niger'
                                                                | 'Nigeria'
                                                                | 'Niue'
                                                                | 'Norfolk Island'
                                                                | 'North Macedonia'
                                                                | 'Northern Mariana Islands'
                                                                | 'Norway'
                                                                | 'Oman'
                                                                | 'Pakistan'
                                                                | 'Palau'
                                                                | 'Palestine, State of'
                                                                | 'Panama'
                                                                | 'Papua New Guinea'
                                                                | 'Paraguay'
                                                                | 'Peru'
                                                                | 'Philippines'
                                                                | 'Pitcairn'
                                                                | 'Poland'
                                                                | 'Portugal'
                                                                | 'Puerto Rico'
                                                                | 'Qatar'
                                                                | 'Réunion'
                                                                | 'Romania'
                                                                | 'Russian Federation'
                                                                | 'Rwanda'
                                                                | 'Saint Barthélemy'
                                                                | 'Saint Helena, Ascension and Tristan da Cunha'
                                                                | 'Saint Kitts and Nevis'
                                                                | 'Saint Lucia'
                                                                | 'Saint Martin (French part)'
                                                                | 'Saint Pierre and Miquelon'
                                                                | 'Saint Vincent and the Grenadines'
                                                                | 'Samoa'
                                                                | 'San Marino'
                                                                | 'São Tomé and Príncipe'
                                                                | 'Saudi Arabia'
                                                                | 'Senegal'
                                                                | 'Serbia'
                                                                | 'Seychelles'
                                                                | 'Sierra Leone'
                                                                | 'Singapore'
                                                                | 'Sint Maarten (Dutch part)'
                                                                | 'Slovakia'
                                                                | 'Slovenia'
                                                                | 'Solomon Islands'
                                                                | 'Somalia'
                                                                | 'South Africa'
                                                                | 'South Georgia and the South Sandwich Islands'
                                                                | 'South Sudan'
                                                                | 'Spain'
                                                                | 'Sri Lanka'
                                                                | 'Sudan'
                                                                | 'Suriname'
                                                                | 'Svalbard and Jan Mayen'
                                                                | 'Sweden'
                                                                | 'Switzerland'
                                                                | 'Syrian Arab Republic'
                                                                | 'Taiwan, Province of China'
                                                                | 'Tajikistan'
                                                                | 'Tanzania, United Republic of'
                                                                | 'Thailand'
                                                                | 'Timor-Leste'
                                                                | 'Togo'
                                                                | 'Tokelau'
                                                                | 'Tonga'
                                                                | 'Trinidad and Tobago'
                                                                | 'Tunisia'
                                                                | 'Türkiye'
                                                                | 'Turkmenistan'
                                                                | 'Turks and Caicos Islands'
                                                                | 'Tuvalu'
                                                                | 'Uganda'
                                                                | 'Ukraine'
                                                                | 'United Arab Emirates'
                                                                | 'United Kingdom of Great Britain and Northern Ireland'
                                                                | 'United States of America'
                                                                | 'United States Minor Outlying Islands'
                                                                | 'Uruguay'
                                                                | 'Uzbekistan'
                                                                | 'Vanuatu'
                                                                | 'Venezuela, Bolivarian Republic of'
                                                                | 'Viet Nam'
                                                                | 'Virgin Islands (British)'
                                                                | 'Virgin Islands (U.S.)'
                                                                | 'Wallis and Futuna'
                                                                | 'Western Sahara'
                                                                | 'Yemen'
                                                                | 'Zambia'
                                                                | 'Zimbabwe'
                                                                >;

                                                                  variable GraphQLCuid

                                                                  const GraphQLCuid: GraphQLScalarType<string, string>;

                                                                    variable GraphQLCurrency

                                                                    const GraphQLCurrency: GraphQLScalarType<string, string>;

                                                                      variable GraphQLDate

                                                                      const GraphQLDate: GraphQLScalarType<Date, string>;
                                                                      • An RFC 3339 compliant date scalar.

                                                                        Input: This scalar takes an RFC 3339 date string as input and parses it to a javascript Date.

                                                                        Output: This scalar serializes javascript Dates and RFC 3339 date strings to RFC 3339 date strings.

                                                                      variable GraphQLDateTime

                                                                      const GraphQLDateTime: GraphQLScalarType<Date, Date>;
                                                                      • An RFC 3339 compliant date-time scalar.

                                                                        Input: This scalar takes an RFC 3339 date-time string as input and parses it to a javascript Date.

                                                                        Output: This scalar serializes javascript Dates, RFC 3339 date-time strings and unix timestamps to RFC 3339 UTC date-time strings.

                                                                      variable GraphQLDateTimeISO

                                                                      const GraphQLDateTimeISO: GraphQLScalarType<Date, string>;

                                                                        variable GraphQLDeweyDecimal

                                                                        const GraphQLDeweyDecimal: GraphQLScalarType<string, string>;

                                                                          variable GraphQLDeweyDecimalResolver

                                                                          const GraphQLDeweyDecimalResolver: GraphQLScalarType<string, string>;

                                                                            variable GraphQLDID

                                                                            const GraphQLDID: GraphQLScalarType<string, string>;

                                                                              variable GraphQLDuration

                                                                              const GraphQLDuration: GraphQLScalarType<string, string>;

                                                                                variable GraphQLEmailAddress

                                                                                const GraphQLEmailAddress: GraphQLScalarType<string, string>;

                                                                                  variable GraphQLGeoJSON

                                                                                  const GraphQLGeoJSON: GraphQLScalarType<GeoJSONObject, GeoJSONObject>;

                                                                                    variable GraphQLGUID

                                                                                    const GraphQLGUID: GraphQLScalarType<string, string>;

                                                                                      variable GraphQLHexadecimal

                                                                                      const GraphQLHexadecimal: GraphQLScalarType<string, string>;

                                                                                        variable GraphQLHexColorCode

                                                                                        const GraphQLHexColorCode: GraphQLScalarType<string, string>;

                                                                                          variable GraphQLHSL

                                                                                          const GraphQLHSL: GraphQLScalarType<string, string>;

                                                                                            variable GraphQLHSLA

                                                                                            const GraphQLHSLA: GraphQLScalarType<string, string>;

                                                                                              variable GraphQLIBAN

                                                                                              const GraphQLIBAN: GraphQLScalarType<string, string>;

                                                                                                variable GraphQLIP

                                                                                                const GraphQLIP: GraphQLScalarType<string, string>;

                                                                                                  variable GraphQLIPCPatent

                                                                                                  const GraphQLIPCPatent: GraphQLScalarType<string, string>;

                                                                                                    variable GraphQLIPCPatentResolver

                                                                                                    const GraphQLIPCPatentResolver: GraphQLScalarType<string, string>;

                                                                                                      variable GraphQLIPv4

                                                                                                      const GraphQLIPv4: GraphQLScalarType<string, string>;

                                                                                                        variable GraphQLIPv6

                                                                                                        const GraphQLIPv6: GraphQLScalarType<string, string>;

                                                                                                          variable GraphQLISBN

                                                                                                          const GraphQLISBN: GraphQLScalarType<string, string>;

                                                                                                            variable GraphQLISO8601Duration

                                                                                                            const GraphQLISO8601Duration: GraphQLScalarType<string, string>;

                                                                                                              variable GraphQLJSON

                                                                                                              const GraphQLJSON: GraphQLScalarType<any, any>;

                                                                                                                variable GraphQLJSONObject

                                                                                                                const GraphQLJSONObject: GraphQLScalarType<object, object>;

                                                                                                                  variable GraphQLJWT

                                                                                                                  const GraphQLJWT: GraphQLScalarType<string, string>;

                                                                                                                    variable GraphQLLatitude

                                                                                                                    const GraphQLLatitude: GraphQLScalarType<number, number>;

                                                                                                                      variable GraphQLLCCSubclass

                                                                                                                      const GraphQLLCCSubclass: GraphQLScalarType<string, string>;

                                                                                                                        variable GraphQLLocalDate

                                                                                                                        const GraphQLLocalDate: GraphQLScalarType<string, string>;

                                                                                                                          variable GraphQLLocalDateTime

                                                                                                                          const GraphQLLocalDateTime: GraphQLScalarType<string, string>;

                                                                                                                            variable GraphQLLocale

                                                                                                                            const GraphQLLocale: GraphQLScalarType<string, string>;

                                                                                                                              variable GraphQLLocalEndTime

                                                                                                                              const GraphQLLocalEndTime: GraphQLScalarType<any, any>;

                                                                                                                                variable GraphQLLocalTime

                                                                                                                                const GraphQLLocalTime: GraphQLScalarType<string, string>;

                                                                                                                                  variable GraphQLLong

                                                                                                                                  const GraphQLLong: GraphQLScalarType<number | bigint, string | number | bigint>;

                                                                                                                                    variable GraphQLLongitude

                                                                                                                                    const GraphQLLongitude: GraphQLScalarType<number, number>;

                                                                                                                                      variable GraphQLMAC

                                                                                                                                      const GraphQLMAC: GraphQLScalarType<string, string>;

                                                                                                                                        variable GraphQLNegativeFloat

                                                                                                                                        const GraphQLNegativeFloat: GraphQLScalarType<number, number>;

                                                                                                                                          variable GraphQLNegativeInt

                                                                                                                                          const GraphQLNegativeInt: GraphQLScalarType<number, number>;

                                                                                                                                            variable GraphQLNonEmptyString

                                                                                                                                            const GraphQLNonEmptyString: GraphQLScalarType<string, string>;

                                                                                                                                              variable GraphQLNonNegativeFloat

                                                                                                                                              const GraphQLNonNegativeFloat: GraphQLScalarType<any, any>;

                                                                                                                                                variable GraphQLNonNegativeInt

                                                                                                                                                const GraphQLNonNegativeInt: GraphQLScalarType<any, any>;

                                                                                                                                                  variable GraphQLNonPositiveFloat

                                                                                                                                                  const GraphQLNonPositiveFloat: GraphQLScalarType<number, number>;

                                                                                                                                                    variable GraphQLNonPositiveInt

                                                                                                                                                    const GraphQLNonPositiveInt: GraphQLScalarType<number, number>;

                                                                                                                                                      variable GraphQLObjectID

                                                                                                                                                      const GraphQLObjectID: GraphQLScalarType<string, string>;

                                                                                                                                                        variable GraphQLPhoneNumber

                                                                                                                                                        const GraphQLPhoneNumber: GraphQLScalarType<string, string>;

                                                                                                                                                          variable GraphQLPort

                                                                                                                                                          const GraphQLPort: GraphQLScalarType<number, number>;

                                                                                                                                                            variable GraphQLPositiveFloat

                                                                                                                                                            const GraphQLPositiveFloat: GraphQLScalarType<number, number>;

                                                                                                                                                              variable GraphQLPositiveInt

                                                                                                                                                              const GraphQLPositiveInt: GraphQLScalarType<number, number>;

                                                                                                                                                                variable GraphQLPostalCode

                                                                                                                                                                const GraphQLPostalCode: GraphQLScalarType<string, string>;

                                                                                                                                                                  variable GraphQLRGB

                                                                                                                                                                  const GraphQLRGB: GraphQLScalarType<string, string>;

                                                                                                                                                                    variable GraphQLRGBA

                                                                                                                                                                    const GraphQLRGBA: GraphQLScalarType<string, string>;

                                                                                                                                                                      variable GraphQLRoutingNumber

                                                                                                                                                                      const GraphQLRoutingNumber: GraphQLScalarType<string, string>;

                                                                                                                                                                        variable GraphQLSafeInt

                                                                                                                                                                        const GraphQLSafeInt: GraphQLScalarType<string | number, number>;

                                                                                                                                                                          variable GraphQLSemVer

                                                                                                                                                                          const GraphQLSemVer: GraphQLScalarType<string, string>;

                                                                                                                                                                            variable GraphQLSESSN

                                                                                                                                                                            const GraphQLSESSN: GraphQLScalarType;

                                                                                                                                                                              variable GraphQLTime

                                                                                                                                                                              const GraphQLTime: GraphQLScalarType<Date, string>;

                                                                                                                                                                                variable GraphQLTimestamp

                                                                                                                                                                                const GraphQLTimestamp: GraphQLScalarType<Date, number>;

                                                                                                                                                                                  variable GraphQLTimeZone

                                                                                                                                                                                  const GraphQLTimeZone: GraphQLScalarType<string, string>;

                                                                                                                                                                                    variable GraphQLUnsignedFloat

                                                                                                                                                                                    const GraphQLUnsignedFloat: GraphQLScalarType<any, any>;

                                                                                                                                                                                      variable GraphQLUnsignedInt

                                                                                                                                                                                      const GraphQLUnsignedInt: GraphQLScalarType<any, any>;

                                                                                                                                                                                        variable GraphQLURL

                                                                                                                                                                                        const GraphQLURL: GraphQLScalarType<unknown, unknown>;

                                                                                                                                                                                          variable GraphQLUSCurrency

                                                                                                                                                                                          const GraphQLUSCurrency: GraphQLScalarType<number, string>;
                                                                                                                                                                                          • An Currency Scalar.

                                                                                                                                                                                            Input: This scalar takes a currency string as input and formats it to currency in cents.

                                                                                                                                                                                            Output: This scalar serializes currency in cents to currency strings.

                                                                                                                                                                                          variable GraphQLUtcOffset

                                                                                                                                                                                          const GraphQLUtcOffset: GraphQLScalarType<string, string>;

                                                                                                                                                                                            variable GraphQLUUID

                                                                                                                                                                                            const GraphQLUUID: GraphQLScalarType<string, string>;

                                                                                                                                                                                              variable GraphQLVoid

                                                                                                                                                                                              const GraphQLVoid: GraphQLScalarType<null, string>;

                                                                                                                                                                                                variable GUIDDefinition

                                                                                                                                                                                                const GUIDDefinition: string;

                                                                                                                                                                                                  variable GUIDResolver

                                                                                                                                                                                                  const GUIDResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                    variable HexadecimalResolver

                                                                                                                                                                                                    const HexadecimalResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                      variable HexadecimalTypeDefinition

                                                                                                                                                                                                      const HexadecimalTypeDefinition: string;

                                                                                                                                                                                                        variable HexColorCodeDefinition

                                                                                                                                                                                                        const HexColorCodeDefinition: string;

                                                                                                                                                                                                          variable HexColorCodeResolver

                                                                                                                                                                                                          const HexColorCodeResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                            variable HSLADefinition

                                                                                                                                                                                                            const HSLADefinition: string;

                                                                                                                                                                                                              variable HSLAResolver

                                                                                                                                                                                                              const HSLAResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                variable HSLDefinition

                                                                                                                                                                                                                const HSLDefinition: string;

                                                                                                                                                                                                                  variable HSLResolver

                                                                                                                                                                                                                  const HSLResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                    variable IBANResolver

                                                                                                                                                                                                                    const IBANResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                      variable IBANTypeDefinition

                                                                                                                                                                                                                      const IBANTypeDefinition: string;

                                                                                                                                                                                                                        variable IPCPatentDefinition

                                                                                                                                                                                                                        const IPCPatentDefinition: string;

                                                                                                                                                                                                                          variable IPDefinition

                                                                                                                                                                                                                          const IPDefinition: string;

                                                                                                                                                                                                                            variable IPResolver

                                                                                                                                                                                                                            const IPResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                              variable IPv4Definition

                                                                                                                                                                                                                              const IPv4Definition: string;

                                                                                                                                                                                                                                variable IPv4Resolver

                                                                                                                                                                                                                                const IPv4Resolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                  variable IPv6Definition

                                                                                                                                                                                                                                  const IPv6Definition: string;

                                                                                                                                                                                                                                    variable IPv6Resolver

                                                                                                                                                                                                                                    const IPv6Resolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                      variable ISBNDefinition

                                                                                                                                                                                                                                      const ISBNDefinition: string;

                                                                                                                                                                                                                                        variable ISBNResolver

                                                                                                                                                                                                                                        const ISBNResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                          variable ISO8601DurationResolver

                                                                                                                                                                                                                                          const ISO8601DurationResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                            variable JSONDefinition

                                                                                                                                                                                                                                            const JSONDefinition: string;

                                                                                                                                                                                                                                              variable JSONObjectDefinition

                                                                                                                                                                                                                                              const JSONObjectDefinition: string;

                                                                                                                                                                                                                                                variable JSONObjectResolver

                                                                                                                                                                                                                                                const JSONObjectResolver: GraphQLScalarType<object, object>;

                                                                                                                                                                                                                                                  variable JSONResolver

                                                                                                                                                                                                                                                  const JSONResolver: GraphQLScalarType<any, any>;

                                                                                                                                                                                                                                                    variable JWTDefinition

                                                                                                                                                                                                                                                    const JWTDefinition: string;

                                                                                                                                                                                                                                                      variable JWTResolver

                                                                                                                                                                                                                                                      const JWTResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                        variable LatitudeDefinition

                                                                                                                                                                                                                                                        const LatitudeDefinition: string;

                                                                                                                                                                                                                                                          variable LatitudeResolver

                                                                                                                                                                                                                                                          const LatitudeResolver: GraphQLScalarType<number, number>;

                                                                                                                                                                                                                                                            variable LCCSubclassDefinition

                                                                                                                                                                                                                                                            const LCCSubclassDefinition: string;

                                                                                                                                                                                                                                                              variable LocalDateResolver

                                                                                                                                                                                                                                                              const LocalDateResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                variable LocalDateTimeResolver

                                                                                                                                                                                                                                                                const LocalDateTimeResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                  variable LocalDateTimeTypeDefinition

                                                                                                                                                                                                                                                                  const LocalDateTimeTypeDefinition: string;

                                                                                                                                                                                                                                                                    variable LocalDateTypeDefinition

                                                                                                                                                                                                                                                                    const LocalDateTypeDefinition: string;

                                                                                                                                                                                                                                                                      variable LocaleDefinition

                                                                                                                                                                                                                                                                      const LocaleDefinition: string;

                                                                                                                                                                                                                                                                        variable LocalEndTimeResolver

                                                                                                                                                                                                                                                                        const LocalEndTimeResolver: GraphQLScalarType<any, any>;

                                                                                                                                                                                                                                                                          variable LocalEndTimeTypeDefinition

                                                                                                                                                                                                                                                                          const LocalEndTimeTypeDefinition: string;

                                                                                                                                                                                                                                                                            variable LocaleResolver

                                                                                                                                                                                                                                                                            const LocaleResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                              variable LocalTimeResolver

                                                                                                                                                                                                                                                                              const LocalTimeResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                                variable LocalTimeTypeDefinition

                                                                                                                                                                                                                                                                                const LocalTimeTypeDefinition: string;

                                                                                                                                                                                                                                                                                  variable LongitudeDefinition

                                                                                                                                                                                                                                                                                  const LongitudeDefinition: string;

                                                                                                                                                                                                                                                                                    variable LongitudeResolver

                                                                                                                                                                                                                                                                                    const LongitudeResolver: GraphQLScalarType<number, number>;

                                                                                                                                                                                                                                                                                      variable LongResolver

                                                                                                                                                                                                                                                                                      const LongResolver: GraphQLScalarType<number | bigint, string | number | bigint>;

                                                                                                                                                                                                                                                                                        variable LongTypeDefinition

                                                                                                                                                                                                                                                                                        const LongTypeDefinition: string;

                                                                                                                                                                                                                                                                                          variable MACDefinition

                                                                                                                                                                                                                                                                                          const MACDefinition: string;

                                                                                                                                                                                                                                                                                            variable MACResolver

                                                                                                                                                                                                                                                                                            const MACResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                                              variable NegativeFloatResolver

                                                                                                                                                                                                                                                                                              const NegativeFloatResolver: GraphQLScalarType<number, number>;

                                                                                                                                                                                                                                                                                                variable NegativeFloatTypeDefinition

                                                                                                                                                                                                                                                                                                const NegativeFloatTypeDefinition: string;

                                                                                                                                                                                                                                                                                                  variable NegativeIntResolver

                                                                                                                                                                                                                                                                                                  const NegativeIntResolver: GraphQLScalarType<number, number>;

                                                                                                                                                                                                                                                                                                    variable NegativeIntTypeDefinition

                                                                                                                                                                                                                                                                                                    const NegativeIntTypeDefinition: string;

                                                                                                                                                                                                                                                                                                      variable NonEmptyStringResolver

                                                                                                                                                                                                                                                                                                      const NonEmptyStringResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                                                        variable NonEmptyStringTypeDefinition

                                                                                                                                                                                                                                                                                                        const NonEmptyStringTypeDefinition: string;

                                                                                                                                                                                                                                                                                                          variable NonNegativeFloatResolver

                                                                                                                                                                                                                                                                                                          const NonNegativeFloatResolver: GraphQLScalarType<any, any>;

                                                                                                                                                                                                                                                                                                            variable NonNegativeFloatTypeDefinition

                                                                                                                                                                                                                                                                                                            const NonNegativeFloatTypeDefinition: string;

                                                                                                                                                                                                                                                                                                              variable NonNegativeIntResolver

                                                                                                                                                                                                                                                                                                              const NonNegativeIntResolver: GraphQLScalarType<any, any>;

                                                                                                                                                                                                                                                                                                                variable NonNegativeIntTypeDefinition

                                                                                                                                                                                                                                                                                                                const NonNegativeIntTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                  variable NonPositiveFloatResolver

                                                                                                                                                                                                                                                                                                                  const NonPositiveFloatResolver: GraphQLScalarType<number, number>;

                                                                                                                                                                                                                                                                                                                    variable NonPositiveFloatTypeDefinition

                                                                                                                                                                                                                                                                                                                    const NonPositiveFloatTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                      variable NonPositiveIntResolver

                                                                                                                                                                                                                                                                                                                      const NonPositiveIntResolver: GraphQLScalarType<number, number>;

                                                                                                                                                                                                                                                                                                                        variable NonPositiveIntTypeDefinition

                                                                                                                                                                                                                                                                                                                        const NonPositiveIntTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                          variable ObjectIDResolver

                                                                                                                                                                                                                                                                                                                          const ObjectIDResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                                                                            variable ObjectIDTypeDefinition

                                                                                                                                                                                                                                                                                                                            const ObjectIDTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                              variable PhoneNumberResolver

                                                                                                                                                                                                                                                                                                                              const PhoneNumberResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                                                                                variable PhoneNumberTypeDefinition

                                                                                                                                                                                                                                                                                                                                const PhoneNumberTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                                  variable PortDefinition

                                                                                                                                                                                                                                                                                                                                  const PortDefinition: string;

                                                                                                                                                                                                                                                                                                                                    variable PortResolver

                                                                                                                                                                                                                                                                                                                                    const PortResolver: GraphQLScalarType<number, number>;

                                                                                                                                                                                                                                                                                                                                      variable PositiveFloatResolver

                                                                                                                                                                                                                                                                                                                                      const PositiveFloatResolver: GraphQLScalarType<number, number>;

                                                                                                                                                                                                                                                                                                                                        variable PositiveFloatTypeDefinition

                                                                                                                                                                                                                                                                                                                                        const PositiveFloatTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                                          variable PositiveIntResolver

                                                                                                                                                                                                                                                                                                                                          const PositiveIntResolver: GraphQLScalarType<number, number>;

                                                                                                                                                                                                                                                                                                                                            variable PositiveIntTypeDefinition

                                                                                                                                                                                                                                                                                                                                            const PositiveIntTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                                              variable PostalCodeResolver

                                                                                                                                                                                                                                                                                                                                              const PostalCodeResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                                                                                                variable PostalCodeTypeDefinition

                                                                                                                                                                                                                                                                                                                                                const PostalCodeTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                                                  variable resolvers

                                                                                                                                                                                                                                                                                                                                                  const resolvers: Record<string, GraphQLScalarType>;

                                                                                                                                                                                                                                                                                                                                                    variable RGBADefinition

                                                                                                                                                                                                                                                                                                                                                    const RGBADefinition: string;

                                                                                                                                                                                                                                                                                                                                                      variable RGBAResolver

                                                                                                                                                                                                                                                                                                                                                      const RGBAResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                                                                                                        variable RGBDefinition

                                                                                                                                                                                                                                                                                                                                                        const RGBDefinition: string;

                                                                                                                                                                                                                                                                                                                                                          variable RGBResolver

                                                                                                                                                                                                                                                                                                                                                          const RGBResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                                                                                                            variable RoutingNumberDefinition

                                                                                                                                                                                                                                                                                                                                                            const RoutingNumberDefinition: string;

                                                                                                                                                                                                                                                                                                                                                              variable RoutingNumberResolver

                                                                                                                                                                                                                                                                                                                                                              const RoutingNumberResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                                                                                                                variable SafeIntDefinition

                                                                                                                                                                                                                                                                                                                                                                const SafeIntDefinition: string;

                                                                                                                                                                                                                                                                                                                                                                  variable SafeIntResolver

                                                                                                                                                                                                                                                                                                                                                                  const SafeIntResolver: GraphQLScalarType<string | number, number>;

                                                                                                                                                                                                                                                                                                                                                                    variable SemVerDefinition

                                                                                                                                                                                                                                                                                                                                                                    const SemVerDefinition: string;

                                                                                                                                                                                                                                                                                                                                                                      variable SemVerResolver

                                                                                                                                                                                                                                                                                                                                                                      const SemVerResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                                                                                                                        variable SESSNDefinition

                                                                                                                                                                                                                                                                                                                                                                        const SESSNDefinition: string;

                                                                                                                                                                                                                                                                                                                                                                          variable SESSNResolver

                                                                                                                                                                                                                                                                                                                                                                          const SESSNResolver: GraphQLScalarType;

                                                                                                                                                                                                                                                                                                                                                                            variable TimeResolver

                                                                                                                                                                                                                                                                                                                                                                            const TimeResolver: GraphQLScalarType<Date, string>;

                                                                                                                                                                                                                                                                                                                                                                              variable TimestampResolver

                                                                                                                                                                                                                                                                                                                                                                              const TimestampResolver: GraphQLScalarType<Date, number>;

                                                                                                                                                                                                                                                                                                                                                                                variable TimestampTypeDefinition

                                                                                                                                                                                                                                                                                                                                                                                const TimestampTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                                                                                  variable TimeTypeDefinition

                                                                                                                                                                                                                                                                                                                                                                                  const TimeTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                                                                                    variable TimeZoneResolver

                                                                                                                                                                                                                                                                                                                                                                                    const TimeZoneResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                      variable TimeZoneTypeDefinition

                                                                                                                                                                                                                                                                                                                                                                                      const TimeZoneTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                                                                                        variable typeDefs

                                                                                                                                                                                                                                                                                                                                                                                        const typeDefs: string[];

                                                                                                                                                                                                                                                                                                                                                                                          variable UnsignedFloatResolver

                                                                                                                                                                                                                                                                                                                                                                                          const UnsignedFloatResolver: GraphQLScalarType<any, any>;

                                                                                                                                                                                                                                                                                                                                                                                            variable UnsignedFloatTypeDefinition

                                                                                                                                                                                                                                                                                                                                                                                            const UnsignedFloatTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                                                                                              variable UnsignedIntResolver

                                                                                                                                                                                                                                                                                                                                                                                              const UnsignedIntResolver: GraphQLScalarType<any, any>;

                                                                                                                                                                                                                                                                                                                                                                                                variable UnsignedIntTypeDefinition

                                                                                                                                                                                                                                                                                                                                                                                                const UnsignedIntTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                                                                                                  variable URLResolver

                                                                                                                                                                                                                                                                                                                                                                                                  const URLResolver: GraphQLScalarType<unknown, unknown>;

                                                                                                                                                                                                                                                                                                                                                                                                    variable URLTypeDefinition

                                                                                                                                                                                                                                                                                                                                                                                                    const URLTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                                                                                                      variable USCurrencyDefinition

                                                                                                                                                                                                                                                                                                                                                                                                      const USCurrencyDefinition: string;

                                                                                                                                                                                                                                                                                                                                                                                                        variable USCurrencyResolver

                                                                                                                                                                                                                                                                                                                                                                                                        const USCurrencyResolver: GraphQLScalarType<number, string>;
                                                                                                                                                                                                                                                                                                                                                                                                        • An Currency Scalar.

                                                                                                                                                                                                                                                                                                                                                                                                          Input: This scalar takes a currency string as input and formats it to currency in cents.

                                                                                                                                                                                                                                                                                                                                                                                                          Output: This scalar serializes currency in cents to currency strings.

                                                                                                                                                                                                                                                                                                                                                                                                        variable UtcOffsetResolver

                                                                                                                                                                                                                                                                                                                                                                                                        const UtcOffsetResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                                          variable UtcOffsetTypeDefinition

                                                                                                                                                                                                                                                                                                                                                                                                          const UtcOffsetTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                                                                                                            variable UUIDDefinition

                                                                                                                                                                                                                                                                                                                                                                                                            const UUIDDefinition: string;

                                                                                                                                                                                                                                                                                                                                                                                                              variable UUIDResolver

                                                                                                                                                                                                                                                                                                                                                                                                              const UUIDResolver: GraphQLScalarType<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                variable VoidResolver

                                                                                                                                                                                                                                                                                                                                                                                                                const VoidResolver: GraphQLScalarType<null, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                  variable VoidTypeDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                  const VoidTypeDefinition: string;

                                                                                                                                                                                                                                                                                                                                                                                                                    Functions

                                                                                                                                                                                                                                                                                                                                                                                                                    function AccountNumberMock

                                                                                                                                                                                                                                                                                                                                                                                                                    AccountNumberMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                      function BigIntMock

                                                                                                                                                                                                                                                                                                                                                                                                                      BigIntMock: () => bigint;

                                                                                                                                                                                                                                                                                                                                                                                                                        function ByteMock

                                                                                                                                                                                                                                                                                                                                                                                                                        ByteMock: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                          function CountryCodeMock

                                                                                                                                                                                                                                                                                                                                                                                                                          CountryCodeMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                            function CountryNameMock

                                                                                                                                                                                                                                                                                                                                                                                                                            CountryNameMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                              function CuidMock

                                                                                                                                                                                                                                                                                                                                                                                                                              CuidMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                function CurrencyMock

                                                                                                                                                                                                                                                                                                                                                                                                                                CurrencyMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                  function DateMock

                                                                                                                                                                                                                                                                                                                                                                                                                                  DateMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                    function DateTimeISOMock

                                                                                                                                                                                                                                                                                                                                                                                                                                    DateTimeISOMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                      function DateTimeMock

                                                                                                                                                                                                                                                                                                                                                                                                                                      DateTimeMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        function DeweyDecimalMock

                                                                                                                                                                                                                                                                                                                                                                                                                                        DeweyDecimalMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                          function DIDMock

                                                                                                                                                                                                                                                                                                                                                                                                                                          DIDMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                            function DurationMock

                                                                                                                                                                                                                                                                                                                                                                                                                                            DurationMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                              function EmailAddressMock

                                                                                                                                                                                                                                                                                                                                                                                                                                              EmailAddressMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                function GeoJSONMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                GeoJSONMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  function GUIDMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                  GUIDMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    function HexadecimalMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                    HexadecimalMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      function HexColorCodeMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                      HexColorCodeMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        function HSLAMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                        HSLAMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          function HSLMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                          HSLMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            function IBANMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                            IBANMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              function IPCPatentMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                              IPCPatentMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                function IPMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                IPMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function IPv4Mock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IPv4Mock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function IPv6Mock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IPv6Mock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function ISBNMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ISBNMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function ISO8601DurationMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ISO8601DurationMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function JSONMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          JSONMock: () => {};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function JSONObjectMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            JSONObjectMock: () => {};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function JWTMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              JWTMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function LatitudeMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                LatitudeMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function LCCSubclassMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  LCCSubclassMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function LocalDateMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LocalDateMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function LocalDateTimeMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      LocalDateTimeMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function LocaleMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        LocaleMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function LocalEndTimeMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          LocalEndTimeMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function LocalTimeMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            LocalTimeMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function LongitudeMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LongitudeMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function LongMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                LongMock: () => bigint;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function MACMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MACMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function NegativeFloatMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NegativeFloatMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function NegativeIntMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NegativeIntMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function NonEmptyStringMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NonEmptyStringMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function NonNegativeFloatMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NonNegativeFloatMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function NonNegativeIntMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NonNegativeIntMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function NonPositiveFloatMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NonPositiveFloatMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function NonPositiveIntMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NonPositiveIntMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function ObjectIDMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ObjectIDMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function PhoneNumberMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PhoneNumberMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function PortMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      PortMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function PositiveFloatMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        PositiveFloatMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function PositiveIntMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          PositiveIntMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function PostalCodeMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            PostalCodeMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function RGBAMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RGBAMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function RGBMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                RGBMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function RoutingNumberMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RoutingNumberMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function SafeIntMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SafeIntMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function SemVerMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SemVerMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function SESSNMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SESSNMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function TimeMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TimeMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function TimestampMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TimestampMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function TimeZoneMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TimeZoneMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function UnsignedFloatMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UnsignedFloatMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function UnsignedIntMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  UnsignedIntMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function URLMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    URLMock: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function USCurrencyMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      USCurrencyMock: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function UtcOffsetMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        UtcOffsetMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function UUIDMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          UUIDMock: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function VoidMock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            VoidMock: () => null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Classes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class RegularExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class RegularExpression extends GraphQLScalarType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(name: string, regex: RegExp, options?: RegularExpressionOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RegularExpressionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RegularExpressionOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    description?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property errorMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      errorMessage?: RegularExpressionErrorMessageFn;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property stringOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        stringOnly?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RegularExpressionErrorMessageFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RegularExpressionErrorMessageFn = (r: RegExp, v: any) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace mocks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            module 'typings/mocks.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function AccountNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AccountNumber: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function BigInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                BigInt: () => bigint;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function Byte

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Byte: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function CountryCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CountryCode: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function CountryName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CountryName: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function Cuid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Cuid: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function Currency

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Currency: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function Date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Date: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function DateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DateTime: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function DateTimeISO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DateTimeISO: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function DeweyDecimal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DeweyDecimal: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function DID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DID: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function Duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Duration: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function EmailAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        EmailAddress: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function GeoJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GeoJSON: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function GUID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GUID: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function Hexadecimal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Hexadecimal: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function HexColorCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                HexColorCode: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function HSL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  HSL: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function HSLA

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    HSLA: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function IBAN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      IBAN: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function IP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        IP: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function IPCPatent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          IPCPatent: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function IPv4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            IPv4: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function IPv6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IPv6: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function ISBN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ISBN: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function ISO8601Duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ISO8601Duration: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function JSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    JSON: () => {};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function JSONObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      JSONObject: () => {};

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function JWT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        JWT: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function Latitude

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Latitude: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function LCCSubclass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            LCCSubclass: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function LocalDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LocalDate: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function LocalDateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                LocalDateTime: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function Locale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Locale: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function LocalEndTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LocalEndTime: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function LocalTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      LocalTime: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function Long

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Long: () => bigint;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function Longitude

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Longitude: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function MAC

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MAC: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function NegativeFloat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NegativeFloat: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function NegativeInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NegativeInt: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function NonEmptyString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NonEmptyString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function NonNegativeFloat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NonNegativeFloat: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function NonNegativeInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NonNegativeInt: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function NonPositiveFloat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NonPositiveFloat: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function NonPositiveInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NonPositiveInt: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function ObjectID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ObjectID: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function PhoneNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              PhoneNumber: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function Port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Port: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function PositiveFloat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  PositiveFloat: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function PositiveInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PositiveInt: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function PostalCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      PostalCode: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function RGB

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RGB: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function RGBA

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          RGBA: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function RoutingNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            RoutingNumber: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function SafeInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SafeInt: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function SemVer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SemVer: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function SESSN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SESSN: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function Time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Time: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function Timestamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Timestamp: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function TimeZone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TimeZone: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function UnsignedFloat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          UnsignedFloat: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function UnsignedInt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            UnsignedInt: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function URL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              URL: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function USCurrency

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                USCurrency: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function UtcOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  UtcOffset: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function UUID

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    UUID: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function Void

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Void: () => null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (72)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Badge

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/graphql-scalars.

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