parse-server 2.8.4 → 8.6.2

package/lib/GraphQL/loaders/defaultGraphQLTypes.js

@@ -0,0 +1,1098 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GLOBAL_OR_OBJECT_ID_ATT = exports.GEO_WITHIN_INPUT = exports.GEO_POINT_WHERE_INPUT = exports.GEO_POINT_INPUT = exports.GEO_POINT_FIELDS = exports.GEO_POINT = exports.GEO_INTERSECTS_INPUT = exports.FILE_WHERE_INPUT = exports.FILE_INPUT = exports.FILE_INFO = exports.FILE = exports.ELEMENT = exports.DATE_WHERE_INPUT = exports.DATE = exports.CREATE_RESULT_FIELDS = exports.CREATED_AT_ATT = exports.COUNT_ATT = exports.CLASS_NAME_ATT = exports.CENTER_SPHERE_INPUT = exports.BYTES_WHERE_INPUT = exports.BYTES = exports.BOX_INPUT = exports.BOOLEAN_WHERE_INPUT = exports.ARRAY_WHERE_INPUT = exports.ARRAY_RESULT = exports.ANY = exports.ACL_INPUT = exports.ACL = void 0;
+Object.defineProperty(exports, "GraphQLUpload", {
+  enumerable: true,
+  get: function () {
+    return _GraphQLUpload.default;
+  }
+});
+exports.serializeDateIso = exports.parseValue = exports.parseStringValue = exports.parseObjectFields = exports.parseListValues = exports.parseIntValue = exports.parseFloatValue = exports.parseFileValue = exports.parseDateIsoValue = exports.parseBooleanValue = exports.options = exports.notInQueryKey = exports.notIn = exports.notEqualTo = exports.matchesRegex = exports.loadArrayResult = exports.load = exports.lessThanOrEqualTo = exports.lessThan = exports.inQueryKey = exports.inOp = exports.greaterThanOrEqualTo = exports.greaterThan = exports.exists = exports.equalTo = exports.WITHIN_INPUT = exports.WHERE_ATT = exports.USER_ACL_INPUT = exports.USER_ACL = exports.UPDATE_RESULT_FIELDS = exports.UPDATED_AT_ATT = exports.TypeValidationError = exports.TEXT_INPUT = exports.SUBQUERY_READ_PREFERENCE_ATT = exports.SUBQUERY_INPUT = exports.STRING_WHERE_INPUT = exports.SKIP_ATT = exports.SESSION_TOKEN_ATT = exports.SELECT_INPUT = exports.SEARCH_INPUT = exports.ROLE_ACL_INPUT = exports.ROLE_ACL = exports.READ_PREFERENCE_ATT = exports.READ_PREFERENCE = exports.READ_OPTIONS_INPUT = exports.READ_OPTIONS_ATT = exports.PUBLIC_ACL_INPUT = exports.PUBLIC_ACL = exports.POLYGON_WHERE_INPUT = exports.POLYGON_INPUT = exports.POLYGON = exports.PARSE_OBJECT_FIELDS = exports.PARSE_OBJECT = exports.OBJECT_WHERE_INPUT = exports.OBJECT_ID_ATT = exports.OBJECT_ID = exports.OBJECT = exports.NUMBER_WHERE_INPUT = exports.LIMIT_ATT = exports.KEY_VALUE_INPUT = exports.INPUT_FIELDS = exports.INCLUDE_READ_PREFERENCE_ATT = exports.ID_WHERE_INPUT = void 0;
+var _graphql = require("graphql");
+var _graphqlRelay = require("graphql-relay");
+var _GraphQLUpload = _interopRequireDefault(require("graphql-upload/GraphQLUpload.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class TypeValidationError extends Error {
+  constructor(value, type) {
+    super(`${value} is not a valid ${type}`);
+  }
+}
+exports.TypeValidationError = TypeValidationError;
+const parseStringValue = value => {
+  if (typeof value === 'string') {
+    return value;
+  }
+  throw new TypeValidationError(value, 'String');
+};
+exports.parseStringValue = parseStringValue;
+const parseIntValue = value => {
+  if (typeof value === 'string') {
+    const int = Number(value);
+    if (Number.isInteger(int)) {
+      return int;
+    }
+  }
+  throw new TypeValidationError(value, 'Int');
+};
+exports.parseIntValue = parseIntValue;
+const parseFloatValue = value => {
+  if (typeof value === 'string') {
+    const float = Number(value);
+    if (!isNaN(float)) {
+      return float;
+    }
+  }
+  throw new TypeValidationError(value, 'Float');
+};
+exports.parseFloatValue = parseFloatValue;
+const parseBooleanValue = value => {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  throw new TypeValidationError(value, 'Boolean');
+};
+exports.parseBooleanValue = parseBooleanValue;
+const parseValue = value => {
+  switch (value.kind) {
+    case _graphql.Kind.STRING:
+      return parseStringValue(value.value);
+    case _graphql.Kind.INT:
+      return parseIntValue(value.value);
+    case _graphql.Kind.FLOAT:
+      return parseFloatValue(value.value);
+    case _graphql.Kind.BOOLEAN:
+      return parseBooleanValue(value.value);
+    case _graphql.Kind.LIST:
+      return parseListValues(value.values);
+    case _graphql.Kind.OBJECT:
+      return parseObjectFields(value.fields);
+    default:
+      return value.value;
+  }
+};
+exports.parseValue = parseValue;
+const parseListValues = values => {
+  if (Array.isArray(values)) {
+    return values.map(value => parseValue(value));
+  }
+  throw new TypeValidationError(values, 'List');
+};
+exports.parseListValues = parseListValues;
+const parseObjectFields = fields => {
+  if (Array.isArray(fields)) {
+    return fields.reduce((object, field) => ({
+      ...object,
+      [field.name.value]: parseValue(field.value)
+    }), {});
+  }
+  throw new TypeValidationError(fields, 'Object');
+};
+exports.parseObjectFields = parseObjectFields;
+const ANY = exports.ANY = new _graphql.GraphQLScalarType({
+  name: 'Any',
+  description: 'The Any scalar type is used in operations and types that involve any type of value.',
+  parseValue: value => value,
+  serialize: value => value,
+  parseLiteral: ast => parseValue(ast)
+});
+const OBJECT = exports.OBJECT = new _graphql.GraphQLScalarType({
+  name: 'Object',
+  description: 'The Object scalar type is used in operations and types that involve objects.',
+  parseValue(value) {
+    if (typeof value === 'object') {
+      return value;
+    }
+    throw new TypeValidationError(value, 'Object');
+  },
+  serialize(value) {
+    if (typeof value === 'object') {
+      return value;
+    }
+    throw new TypeValidationError(value, 'Object');
+  },
+  parseLiteral(ast) {
+    if (ast.kind === _graphql.Kind.OBJECT) {
+      return parseObjectFields(ast.fields);
+    }
+    throw new TypeValidationError(ast.kind, 'Object');
+  }
+});
+const parseDateIsoValue = value => {
+  if (typeof value === 'string') {
+    const date = new Date(value);
+    if (!isNaN(date)) {
+      return date;
+    }
+  } else if (value instanceof Date) {
+    return value;
+  }
+  throw new TypeValidationError(value, 'Date');
+};
+exports.parseDateIsoValue = parseDateIsoValue;
+const serializeDateIso = value => {
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  throw new TypeValidationError(value, 'Date');
+};
+exports.serializeDateIso = serializeDateIso;
+const parseDateIsoLiteral = ast => {
+  if (ast.kind === _graphql.Kind.STRING) {
+    return parseDateIsoValue(ast.value);
+  }
+  throw new TypeValidationError(ast.kind, 'Date');
+};
+const DATE = exports.DATE = new _graphql.GraphQLScalarType({
+  name: 'Date',
+  description: 'The Date scalar type is used in operations and types that involve dates.',
+  parseValue(value) {
+    if (typeof value === 'string' || value instanceof Date) {
+      return {
+        __type: 'Date',
+        iso: parseDateIsoValue(value)
+      };
+    } else if (typeof value === 'object' && value.__type === 'Date' && value.iso) {
+      return {
+        __type: value.__type,
+        iso: parseDateIsoValue(value.iso)
+      };
+    }
+    throw new TypeValidationError(value, 'Date');
+  },
+  serialize(value) {
+    if (typeof value === 'string' || value instanceof Date) {
+      return serializeDateIso(value);
+    } else if (typeof value === 'object' && value.__type === 'Date' && value.iso) {
+      return serializeDateIso(value.iso);
+    }
+    throw new TypeValidationError(value, 'Date');
+  },
+  parseLiteral(ast) {
+    if (ast.kind === _graphql.Kind.STRING) {
+      return {
+        __type: 'Date',
+        iso: parseDateIsoLiteral(ast)
+      };
+    } else if (ast.kind === _graphql.Kind.OBJECT) {
+      const __type = ast.fields.find(field => field.name.value === '__type');
+      const iso = ast.fields.find(field => field.name.value === 'iso');
+      if (__type && __type.value && __type.value.value === 'Date' && iso) {
+        return {
+          __type: __type.value.value,
+          iso: parseDateIsoLiteral(iso.value)
+        };
+      }
+    }
+    throw new TypeValidationError(ast.kind, 'Date');
+  }
+});
+const BYTES = exports.BYTES = new _graphql.GraphQLScalarType({
+  name: 'Bytes',
+  description: 'The Bytes scalar type is used in operations and types that involve base 64 binary data.',
+  parseValue(value) {
+    if (typeof value === 'string') {
+      return {
+        __type: 'Bytes',
+        base64: value
+      };
+    } else if (typeof value === 'object' && value.__type === 'Bytes' && typeof value.base64 === 'string') {
+      return value;
+    }
+    throw new TypeValidationError(value, 'Bytes');
+  },
+  serialize(value) {
+    if (typeof value === 'string') {
+      return value;
+    } else if (typeof value === 'object' && value.__type === 'Bytes' && typeof value.base64 === 'string') {
+      return value.base64;
+    }
+    throw new TypeValidationError(value, 'Bytes');
+  },
+  parseLiteral(ast) {
+    if (ast.kind === _graphql.Kind.STRING) {
+      return {
+        __type: 'Bytes',
+        base64: ast.value
+      };
+    } else if (ast.kind === _graphql.Kind.OBJECT) {
+      const __type = ast.fields.find(field => field.name.value === '__type');
+      const base64 = ast.fields.find(field => field.name.value === 'base64');
+      if (__type && __type.value && __type.value.value === 'Bytes' && base64 && base64.value && typeof base64.value.value === 'string') {
+        return {
+          __type: __type.value.value,
+          base64: base64.value.value
+        };
+      }
+    }
+    throw new TypeValidationError(ast.kind, 'Bytes');
+  }
+});
+const parseFileValue = value => {
+  if (typeof value === 'string') {
+    return {
+      __type: 'File',
+      name: value
+    };
+  } else if (typeof value === 'object' && value.__type === 'File' && typeof value.name === 'string' && (value.url === undefined || typeof value.url === 'string')) {
+    return value;
+  }
+  throw new TypeValidationError(value, 'File');
+};
+exports.parseFileValue = parseFileValue;
+const FILE = exports.FILE = new _graphql.GraphQLScalarType({
+  name: 'File',
+  description: 'The File scalar type is used in operations and types that involve files.',
+  parseValue: parseFileValue,
+  serialize: value => {
+    if (typeof value === 'string') {
+      return value;
+    } else if (typeof value === 'object' && value.__type === 'File' && typeof value.name === 'string' && (value.url === undefined || typeof value.url === 'string')) {
+      return value.name;
+    }
+    throw new TypeValidationError(value, 'File');
+  },
+  parseLiteral(ast) {
+    if (ast.kind === _graphql.Kind.STRING) {
+      return parseFileValue(ast.value);
+    } else if (ast.kind === _graphql.Kind.OBJECT) {
+      const __type = ast.fields.find(field => field.name.value === '__type');
+      const name = ast.fields.find(field => field.name.value === 'name');
+      const url = ast.fields.find(field => field.name.value === 'url');
+      if (__type && __type.value && name && name.value) {
+        return parseFileValue({
+          __type: __type.value.value,
+          name: name.value.value,
+          url: url && url.value ? url.value.value : undefined
+        });
+      }
+    }
+    throw new TypeValidationError(ast.kind, 'File');
+  }
+});
+const FILE_INFO = exports.FILE_INFO = new _graphql.GraphQLObjectType({
+  name: 'FileInfo',
+  description: 'The FileInfo object type is used to return the information about files.',
+  fields: {
+    name: {
+      description: 'This is the file name.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+    },
+    url: {
+      description: 'This is the url in which the file can be downloaded.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+    }
+  }
+});
+const FILE_INPUT = exports.FILE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'FileInput',
+  description: 'If this field is set to null the file will be unlinked (the file will not be deleted on cloud storage).',
+  fields: {
+    file: {
+      description: 'A File Scalar can be an url or a FileInfo object.',
+      type: FILE
+    },
+    upload: {
+      description: 'Use this field if you want to create a new file.',
+      type: _GraphQLUpload.default
+    }
+  }
+});
+const GEO_POINT_FIELDS = exports.GEO_POINT_FIELDS = {
+  latitude: {
+    description: 'This is the latitude.',
+    type: new _graphql.GraphQLNonNull(_graphql.GraphQLFloat)
+  },
+  longitude: {
+    description: 'This is the longitude.',
+    type: new _graphql.GraphQLNonNull(_graphql.GraphQLFloat)
+  }
+};
+const GEO_POINT_INPUT = exports.GEO_POINT_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'GeoPointInput',
+  description: 'The GeoPointInput type is used in operations that involve inputting fields of type geo point.',
+  fields: GEO_POINT_FIELDS
+});
+const GEO_POINT = exports.GEO_POINT = new _graphql.GraphQLObjectType({
+  name: 'GeoPoint',
+  description: 'The GeoPoint object type is used to return the information about geo point fields.',
+  fields: GEO_POINT_FIELDS
+});
+const POLYGON_INPUT = exports.POLYGON_INPUT = new _graphql.GraphQLList(new _graphql.GraphQLNonNull(GEO_POINT_INPUT));
+const POLYGON = exports.POLYGON = new _graphql.GraphQLList(new _graphql.GraphQLNonNull(GEO_POINT));
+const USER_ACL_INPUT = exports.USER_ACL_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'UserACLInput',
+  description: 'Allow to manage users in ACL.',
+  fields: {
+    userId: {
+      description: 'ID of the targetted User.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLID)
+    },
+    read: {
+      description: 'Allow the user to read the current object.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+    },
+    write: {
+      description: 'Allow the user to write on the current object.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+    }
+  }
+});
+const ROLE_ACL_INPUT = exports.ROLE_ACL_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'RoleACLInput',
+  description: 'Allow to manage roles in ACL.',
+  fields: {
+    roleName: {
+      description: 'Name of the targetted Role.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+    },
+    read: {
+      description: 'Allow users who are members of the role to read the current object.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+    },
+    write: {
+      description: 'Allow users who are members of the role to write on the current object.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+    }
+  }
+});
+const PUBLIC_ACL_INPUT = exports.PUBLIC_ACL_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'PublicACLInput',
+  description: 'Allow to manage public rights.',
+  fields: {
+    read: {
+      description: 'Allow anyone to read the current object.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+    },
+    write: {
+      description: 'Allow anyone to write on the current object.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+    }
+  }
+});
+const ACL_INPUT = exports.ACL_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'ACLInput',
+  description: 'Allow to manage access rights. If not provided object will be publicly readable and writable',
+  fields: {
+    users: {
+      description: 'Access control list for users.',
+      type: new _graphql.GraphQLList(new _graphql.GraphQLNonNull(USER_ACL_INPUT))
+    },
+    roles: {
+      description: 'Access control list for roles.',
+      type: new _graphql.GraphQLList(new _graphql.GraphQLNonNull(ROLE_ACL_INPUT))
+    },
+    public: {
+      description: 'Public access control list.',
+      type: PUBLIC_ACL_INPUT
+    }
+  }
+});
+const USER_ACL = exports.USER_ACL = new _graphql.GraphQLObjectType({
+  name: 'UserACL',
+  description: 'Allow to manage users in ACL. If read and write are null the users have read and write rights.',
+  fields: {
+    userId: {
+      description: 'ID of the targetted User.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLID)
+    },
+    read: {
+      description: 'Allow the user to read the current object.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+    },
+    write: {
+      description: 'Allow the user to write on the current object.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+    }
+  }
+});
+const ROLE_ACL = exports.ROLE_ACL = new _graphql.GraphQLObjectType({
+  name: 'RoleACL',
+  description: 'Allow to manage roles in ACL. If read and write are null the role have read and write rights.',
+  fields: {
+    roleName: {
+      description: 'Name of the targetted Role.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLID)
+    },
+    read: {
+      description: 'Allow users who are members of the role to read the current object.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+    },
+    write: {
+      description: 'Allow users who are members of the role to write on the current object.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLBoolean)
+    }
+  }
+});
+const PUBLIC_ACL = exports.PUBLIC_ACL = new _graphql.GraphQLObjectType({
+  name: 'PublicACL',
+  description: 'Allow to manage public rights.',
+  fields: {
+    read: {
+      description: 'Allow anyone to read the current object.',
+      type: _graphql.GraphQLBoolean
+    },
+    write: {
+      description: 'Allow anyone to write on the current object.',
+      type: _graphql.GraphQLBoolean
+    }
+  }
+});
+const ACL = exports.ACL = new _graphql.GraphQLObjectType({
+  name: 'ACL',
+  description: 'Current access control list of the current object.',
+  fields: {
+    users: {
+      description: 'Access control list for users.',
+      type: new _graphql.GraphQLList(new _graphql.GraphQLNonNull(USER_ACL)),
+      resolve(p) {
+        const users = [];
+        Object.keys(p).forEach(rule => {
+          if (rule !== '*' && rule.indexOf('role:') !== 0) {
+            users.push({
+              userId: (0, _graphqlRelay.toGlobalId)('_User', rule),
+              read: p[rule].read ? true : false,
+              write: p[rule].write ? true : false
+            });
+          }
+        });
+        return users.length ? users : null;
+      }
+    },
+    roles: {
+      description: 'Access control list for roles.',
+      type: new _graphql.GraphQLList(new _graphql.GraphQLNonNull(ROLE_ACL)),
+      resolve(p) {
+        const roles = [];
+        Object.keys(p).forEach(rule => {
+          if (rule.indexOf('role:') === 0) {
+            roles.push({
+              roleName: rule.replace('role:', ''),
+              read: p[rule].read ? true : false,
+              write: p[rule].write ? true : false
+            });
+          }
+        });
+        return roles.length ? roles : null;
+      }
+    },
+    public: {
+      description: 'Public access control list.',
+      type: PUBLIC_ACL,
+      resolve(p) {
+        /* eslint-disable */
+        return p['*'] ? {
+          read: p['*'].read ? true : false,
+          write: p['*'].write ? true : false
+        } : null;
+      }
+    }
+  }
+});
+const OBJECT_ID = exports.OBJECT_ID = new _graphql.GraphQLNonNull(_graphql.GraphQLID);
+const CLASS_NAME_ATT = exports.CLASS_NAME_ATT = {
+  description: 'This is the class name of the object.',
+  type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+};
+const GLOBAL_OR_OBJECT_ID_ATT = exports.GLOBAL_OR_OBJECT_ID_ATT = {
+  description: 'This is the object id. You can use either the global or the object id.',
+  type: OBJECT_ID
+};
+const OBJECT_ID_ATT = exports.OBJECT_ID_ATT = {
+  description: 'This is the object id.',
+  type: OBJECT_ID
+};
+const CREATED_AT_ATT = exports.CREATED_AT_ATT = {
+  description: 'This is the date in which the object was created.',
+  type: new _graphql.GraphQLNonNull(DATE)
+};
+const UPDATED_AT_ATT = exports.UPDATED_AT_ATT = {
+  description: 'This is the date in which the object was las updated.',
+  type: new _graphql.GraphQLNonNull(DATE)
+};
+const INPUT_FIELDS = exports.INPUT_FIELDS = {
+  ACL: {
+    type: ACL
+  }
+};
+const CREATE_RESULT_FIELDS = exports.CREATE_RESULT_FIELDS = {
+  objectId: OBJECT_ID_ATT,
+  createdAt: CREATED_AT_ATT
+};
+const UPDATE_RESULT_FIELDS = exports.UPDATE_RESULT_FIELDS = {
+  updatedAt: UPDATED_AT_ATT
+};
+const PARSE_OBJECT_FIELDS = exports.PARSE_OBJECT_FIELDS = {
+  ...CREATE_RESULT_FIELDS,
+  ...UPDATE_RESULT_FIELDS,
+  ...INPUT_FIELDS,
+  ACL: {
+    type: new _graphql.GraphQLNonNull(ACL),
+    resolve: ({
+      ACL
+    }) => ACL ? ACL : {
+      '*': {
+        read: true,
+        write: true
+      }
+    }
+  }
+};
+const PARSE_OBJECT = exports.PARSE_OBJECT = new _graphql.GraphQLInterfaceType({
+  name: 'ParseObject',
+  description: 'The ParseObject interface type is used as a base type for the auto generated object types.',
+  fields: PARSE_OBJECT_FIELDS
+});
+const SESSION_TOKEN_ATT = exports.SESSION_TOKEN_ATT = {
+  description: 'The current user session token.',
+  type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+};
+const READ_PREFERENCE = exports.READ_PREFERENCE = new _graphql.GraphQLEnumType({
+  name: 'ReadPreference',
+  description: 'The ReadPreference enum type is used in queries in order to select in which database replica the operation must run.',
+  values: {
+    PRIMARY: {
+      value: 'PRIMARY'
+    },
+    PRIMARY_PREFERRED: {
+      value: 'PRIMARY_PREFERRED'
+    },
+    SECONDARY: {
+      value: 'SECONDARY'
+    },
+    SECONDARY_PREFERRED: {
+      value: 'SECONDARY_PREFERRED'
+    },
+    NEAREST: {
+      value: 'NEAREST'
+    }
+  }
+});
+const READ_PREFERENCE_ATT = exports.READ_PREFERENCE_ATT = {
+  description: 'The read preference for the main query to be executed.',
+  type: READ_PREFERENCE
+};
+const INCLUDE_READ_PREFERENCE_ATT = exports.INCLUDE_READ_PREFERENCE_ATT = {
+  description: 'The read preference for the queries to be executed to include fields.',
+  type: READ_PREFERENCE
+};
+const SUBQUERY_READ_PREFERENCE_ATT = exports.SUBQUERY_READ_PREFERENCE_ATT = {
+  description: 'The read preference for the subqueries that may be required.',
+  type: READ_PREFERENCE
+};
+const READ_OPTIONS_INPUT = exports.READ_OPTIONS_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'ReadOptionsInput',
+  description: 'The ReadOptionsInputt type is used in queries in order to set the read preferences.',
+  fields: {
+    readPreference: READ_PREFERENCE_ATT,
+    includeReadPreference: INCLUDE_READ_PREFERENCE_ATT,
+    subqueryReadPreference: SUBQUERY_READ_PREFERENCE_ATT
+  }
+});
+const READ_OPTIONS_ATT = exports.READ_OPTIONS_ATT = {
+  description: 'The read options for the query to be executed.',
+  type: READ_OPTIONS_INPUT
+};
+const WHERE_ATT = exports.WHERE_ATT = {
+  description: 'These are the conditions that the objects need to match in order to be found',
+  type: OBJECT
+};
+const SKIP_ATT = exports.SKIP_ATT = {
+  description: 'This is the number of objects that must be skipped to return.',
+  type: _graphql.GraphQLInt
+};
+const LIMIT_ATT = exports.LIMIT_ATT = {
+  description: 'This is the limit number of objects that must be returned.',
+  type: _graphql.GraphQLInt
+};
+const COUNT_ATT = exports.COUNT_ATT = {
+  description: 'This is the total matched objecs count that is returned when the count flag is set.',
+  type: new _graphql.GraphQLNonNull(_graphql.GraphQLInt)
+};
+const SEARCH_INPUT = exports.SEARCH_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'SearchInput',
+  description: 'The SearchInput type is used to specifiy a search operation on a full text search.',
+  fields: {
+    term: {
+      description: 'This is the term to be searched.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+    },
+    language: {
+      description: 'This is the language to tetermine the list of stop words and the rules for tokenizer.',
+      type: _graphql.GraphQLString
+    },
+    caseSensitive: {
+      description: 'This is the flag to enable or disable case sensitive search.',
+      type: _graphql.GraphQLBoolean
+    },
+    diacriticSensitive: {
+      description: 'This is the flag to enable or disable diacritic sensitive search.',
+      type: _graphql.GraphQLBoolean
+    }
+  }
+});
+const TEXT_INPUT = exports.TEXT_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'TextInput',
+  description: 'The TextInput type is used to specify a text operation on a constraint.',
+  fields: {
+    search: {
+      description: 'This is the search to be executed.',
+      type: new _graphql.GraphQLNonNull(SEARCH_INPUT)
+    }
+  }
+});
+const BOX_INPUT = exports.BOX_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'BoxInput',
+  description: 'The BoxInput type is used to specifiy a box operation on a within geo query.',
+  fields: {
+    bottomLeft: {
+      description: 'This is the bottom left coordinates of the box.',
+      type: new _graphql.GraphQLNonNull(GEO_POINT_INPUT)
+    },
+    upperRight: {
+      description: 'This is the upper right coordinates of the box.',
+      type: new _graphql.GraphQLNonNull(GEO_POINT_INPUT)
+    }
+  }
+});
+const WITHIN_INPUT = exports.WITHIN_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'WithinInput',
+  description: 'The WithinInput type is used to specify a within operation on a constraint.',
+  fields: {
+    box: {
+      description: 'This is the box to be specified.',
+      type: new _graphql.GraphQLNonNull(BOX_INPUT)
+    }
+  }
+});
+const CENTER_SPHERE_INPUT = exports.CENTER_SPHERE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'CenterSphereInput',
+  description: 'The CenterSphereInput type is used to specifiy a centerSphere operation on a geoWithin query.',
+  fields: {
+    center: {
+      description: 'This is the center of the sphere.',
+      type: new _graphql.GraphQLNonNull(GEO_POINT_INPUT)
+    },
+    distance: {
+      description: 'This is the radius of the sphere.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLFloat)
+    }
+  }
+});
+const GEO_WITHIN_INPUT = exports.GEO_WITHIN_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'GeoWithinInput',
+  description: 'The GeoWithinInput type is used to specify a geoWithin operation on a constraint.',
+  fields: {
+    polygon: {
+      description: 'This is the polygon to be specified.',
+      type: POLYGON_INPUT
+    },
+    centerSphere: {
+      description: 'This is the sphere to be specified.',
+      type: CENTER_SPHERE_INPUT
+    }
+  }
+});
+const GEO_INTERSECTS_INPUT = exports.GEO_INTERSECTS_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'GeoIntersectsInput',
+  description: 'The GeoIntersectsInput type is used to specify a geoIntersects operation on a constraint.',
+  fields: {
+    point: {
+      description: 'This is the point to be specified.',
+      type: GEO_POINT_INPUT
+    }
+  }
+});
+const equalTo = type => ({
+  description: 'This is the equalTo operator to specify a constraint to select the objects where the value of a field equals to a specified value.',
+  type
+});
+exports.equalTo = equalTo;
+const notEqualTo = type => ({
+  description: 'This is the notEqualTo operator to specify a constraint to select the objects where the value of a field do not equal to a specified value.',
+  type
+});
+exports.notEqualTo = notEqualTo;
+const lessThan = type => ({
+  description: 'This is the lessThan operator to specify a constraint to select the objects where the value of a field is less than a specified value.',
+  type
+});
+exports.lessThan = lessThan;
+const lessThanOrEqualTo = type => ({
+  description: 'This is the lessThanOrEqualTo operator to specify a constraint to select the objects where the value of a field is less than or equal to a specified value.',
+  type
+});
+exports.lessThanOrEqualTo = lessThanOrEqualTo;
+const greaterThan = type => ({
+  description: 'This is the greaterThan operator to specify a constraint to select the objects where the value of a field is greater than a specified value.',
+  type
+});
+exports.greaterThan = greaterThan;
+const greaterThanOrEqualTo = type => ({
+  description: 'This is the greaterThanOrEqualTo operator to specify a constraint to select the objects where the value of a field is greater than or equal to a specified value.',
+  type
+});
+exports.greaterThanOrEqualTo = greaterThanOrEqualTo;
+const inOp = type => ({
+  description: 'This is the in operator to specify a constraint to select the objects where the value of a field equals any value in the specified array.',
+  type: new _graphql.GraphQLList(type)
+});
+exports.inOp = inOp;
+const notIn = type => ({
+  description: 'This is the notIn operator to specify a constraint to select the objects where the value of a field do not equal any value in the specified array.',
+  type: new _graphql.GraphQLList(type)
+});
+exports.notIn = notIn;
+const exists = exports.exists = {
+  description: 'This is the exists operator to specify a constraint to select the objects where a field exists (or do not exist).',
+  type: _graphql.GraphQLBoolean
+};
+const matchesRegex = exports.matchesRegex = {
+  description: 'This is the matchesRegex operator to specify a constraint to select the objects where the value of a field matches a specified regular expression.',
+  type: _graphql.GraphQLString
+};
+const options = exports.options = {
+  description: 'This is the options operator to specify optional flags (such as "i" and "m") to be added to a matchesRegex operation in the same set of constraints.',
+  type: _graphql.GraphQLString
+};
+const SUBQUERY_INPUT = exports.SUBQUERY_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'SubqueryInput',
+  description: 'The SubqueryInput type is used to specify a sub query to another class.',
+  fields: {
+    className: CLASS_NAME_ATT,
+    where: Object.assign({}, WHERE_ATT, {
+      type: new _graphql.GraphQLNonNull(WHERE_ATT.type)
+    })
+  }
+});
+const SELECT_INPUT = exports.SELECT_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'SelectInput',
+  description: 'The SelectInput type is used to specify an inQueryKey or a notInQueryKey operation on a constraint.',
+  fields: {
+    query: {
+      description: 'This is the subquery to be executed.',
+      type: new _graphql.GraphQLNonNull(SUBQUERY_INPUT)
+    },
+    key: {
+      description: 'This is the key in the result of the subquery that must match (not match) the field.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+    }
+  }
+});
+const inQueryKey = exports.inQueryKey = {
+  description: 'This is the inQueryKey operator to specify a constraint to select the objects where a field equals to a key in the result of a different query.',
+  type: SELECT_INPUT
+};
+const notInQueryKey = exports.notInQueryKey = {
+  description: 'This is the notInQueryKey operator to specify a constraint to select the objects where a field do not equal to a key in the result of a different query.',
+  type: SELECT_INPUT
+};
+const ID_WHERE_INPUT = exports.ID_WHERE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'IdWhereInput',
+  description: 'The IdWhereInput input type is used in operations that involve filtering objects by an id.',
+  fields: {
+    equalTo: equalTo(_graphql.GraphQLID),
+    notEqualTo: notEqualTo(_graphql.GraphQLID),
+    lessThan: lessThan(_graphql.GraphQLID),
+    lessThanOrEqualTo: lessThanOrEqualTo(_graphql.GraphQLID),
+    greaterThan: greaterThan(_graphql.GraphQLID),
+    greaterThanOrEqualTo: greaterThanOrEqualTo(_graphql.GraphQLID),
+    in: inOp(_graphql.GraphQLID),
+    notIn: notIn(_graphql.GraphQLID),
+    exists,
+    inQueryKey,
+    notInQueryKey
+  }
+});
+const STRING_WHERE_INPUT = exports.STRING_WHERE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'StringWhereInput',
+  description: 'The StringWhereInput input type is used in operations that involve filtering objects by a field of type String.',
+  fields: {
+    equalTo: equalTo(_graphql.GraphQLString),
+    notEqualTo: notEqualTo(_graphql.GraphQLString),
+    lessThan: lessThan(_graphql.GraphQLString),
+    lessThanOrEqualTo: lessThanOrEqualTo(_graphql.GraphQLString),
+    greaterThan: greaterThan(_graphql.GraphQLString),
+    greaterThanOrEqualTo: greaterThanOrEqualTo(_graphql.GraphQLString),
+    in: inOp(_graphql.GraphQLString),
+    notIn: notIn(_graphql.GraphQLString),
+    exists,
+    matchesRegex,
+    options,
+    text: {
+      description: 'This is the $text operator to specify a full text search constraint.',
+      type: TEXT_INPUT
+    },
+    inQueryKey,
+    notInQueryKey
+  }
+});
+const NUMBER_WHERE_INPUT = exports.NUMBER_WHERE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'NumberWhereInput',
+  description: 'The NumberWhereInput input type is used in operations that involve filtering objects by a field of type Number.',
+  fields: {
+    equalTo: equalTo(_graphql.GraphQLFloat),
+    notEqualTo: notEqualTo(_graphql.GraphQLFloat),
+    lessThan: lessThan(_graphql.GraphQLFloat),
+    lessThanOrEqualTo: lessThanOrEqualTo(_graphql.GraphQLFloat),
+    greaterThan: greaterThan(_graphql.GraphQLFloat),
+    greaterThanOrEqualTo: greaterThanOrEqualTo(_graphql.GraphQLFloat),
+    in: inOp(_graphql.GraphQLFloat),
+    notIn: notIn(_graphql.GraphQLFloat),
+    exists,
+    inQueryKey,
+    notInQueryKey
+  }
+});
+const BOOLEAN_WHERE_INPUT = exports.BOOLEAN_WHERE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'BooleanWhereInput',
+  description: 'The BooleanWhereInput input type is used in operations that involve filtering objects by a field of type Boolean.',
+  fields: {
+    equalTo: equalTo(_graphql.GraphQLBoolean),
+    notEqualTo: notEqualTo(_graphql.GraphQLBoolean),
+    exists,
+    inQueryKey,
+    notInQueryKey
+  }
+});
+const ARRAY_WHERE_INPUT = exports.ARRAY_WHERE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'ArrayWhereInput',
+  description: 'The ArrayWhereInput input type is used in operations that involve filtering objects by a field of type Array.',
+  fields: {
+    equalTo: equalTo(ANY),
+    notEqualTo: notEqualTo(ANY),
+    lessThan: lessThan(ANY),
+    lessThanOrEqualTo: lessThanOrEqualTo(ANY),
+    greaterThan: greaterThan(ANY),
+    greaterThanOrEqualTo: greaterThanOrEqualTo(ANY),
+    in: inOp(ANY),
+    notIn: notIn(ANY),
+    exists,
+    containedBy: {
+      description: 'This is the containedBy operator to specify a constraint to select the objects where the values of an array field is contained by another specified array.',
+      type: new _graphql.GraphQLList(ANY)
+    },
+    contains: {
+      description: 'This is the contains operator to specify a constraint to select the objects where the values of an array field contain all elements of another specified array.',
+      type: new _graphql.GraphQLList(ANY)
+    },
+    inQueryKey,
+    notInQueryKey
+  }
+});
+const KEY_VALUE_INPUT = exports.KEY_VALUE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'KeyValueInput',
+  description: 'An entry from an object, i.e., a pair of key and value.',
+  fields: {
+    key: {
+      description: 'The key used to retrieve the value of this entry.',
+      type: new _graphql.GraphQLNonNull(_graphql.GraphQLString)
+    },
+    value: {
+      description: 'The value of the entry. Could be any type of scalar data.',
+      type: new _graphql.GraphQLNonNull(ANY)
+    }
+  }
+});
+const OBJECT_WHERE_INPUT = exports.OBJECT_WHERE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'ObjectWhereInput',
+  description: 'The ObjectWhereInput input type is used in operations that involve filtering result by a field of type Object.',
+  fields: {
+    equalTo: equalTo(KEY_VALUE_INPUT),
+    notEqualTo: notEqualTo(KEY_VALUE_INPUT),
+    in: inOp(KEY_VALUE_INPUT),
+    notIn: notIn(KEY_VALUE_INPUT),
+    lessThan: lessThan(KEY_VALUE_INPUT),
+    lessThanOrEqualTo: lessThanOrEqualTo(KEY_VALUE_INPUT),
+    greaterThan: greaterThan(KEY_VALUE_INPUT),
+    greaterThanOrEqualTo: greaterThanOrEqualTo(KEY_VALUE_INPUT),
+    exists,
+    inQueryKey,
+    notInQueryKey
+  }
+});
+const DATE_WHERE_INPUT = exports.DATE_WHERE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'DateWhereInput',
+  description: 'The DateWhereInput input type is used in operations that involve filtering objects by a field of type Date.',
+  fields: {
+    equalTo: equalTo(DATE),
+    notEqualTo: notEqualTo(DATE),
+    lessThan: lessThan(DATE),
+    lessThanOrEqualTo: lessThanOrEqualTo(DATE),
+    greaterThan: greaterThan(DATE),
+    greaterThanOrEqualTo: greaterThanOrEqualTo(DATE),
+    in: inOp(DATE),
+    notIn: notIn(DATE),
+    exists,
+    inQueryKey,
+    notInQueryKey
+  }
+});
+const BYTES_WHERE_INPUT = exports.BYTES_WHERE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'BytesWhereInput',
+  description: 'The BytesWhereInput input type is used in operations that involve filtering objects by a field of type Bytes.',
+  fields: {
+    equalTo: equalTo(BYTES),
+    notEqualTo: notEqualTo(BYTES),
+    lessThan: lessThan(BYTES),
+    lessThanOrEqualTo: lessThanOrEqualTo(BYTES),
+    greaterThan: greaterThan(BYTES),
+    greaterThanOrEqualTo: greaterThanOrEqualTo(BYTES),
+    in: inOp(BYTES),
+    notIn: notIn(BYTES),
+    exists,
+    inQueryKey,
+    notInQueryKey
+  }
+});
+const FILE_WHERE_INPUT = exports.FILE_WHERE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'FileWhereInput',
+  description: 'The FileWhereInput input type is used in operations that involve filtering objects by a field of type File.',
+  fields: {
+    equalTo: equalTo(FILE),
+    notEqualTo: notEqualTo(FILE),
+    lessThan: lessThan(FILE),
+    lessThanOrEqualTo: lessThanOrEqualTo(FILE),
+    greaterThan: greaterThan(FILE),
+    greaterThanOrEqualTo: greaterThanOrEqualTo(FILE),
+    in: inOp(FILE),
+    notIn: notIn(FILE),
+    exists,
+    matchesRegex,
+    options,
+    inQueryKey,
+    notInQueryKey
+  }
+});
+const GEO_POINT_WHERE_INPUT = exports.GEO_POINT_WHERE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'GeoPointWhereInput',
+  description: 'The GeoPointWhereInput input type is used in operations that involve filtering objects by a field of type GeoPoint.',
+  fields: {
+    exists,
+    nearSphere: {
+      description: 'This is the nearSphere operator to specify a constraint to select the objects where the values of a geo point field is near to another geo point.',
+      type: GEO_POINT_INPUT
+    },
+    maxDistance: {
+      description: 'This is the maxDistance operator to specify a constraint to select the objects where the values of a geo point field is at a max distance (in radians) from the geo point specified in the $nearSphere operator.',
+      type: _graphql.GraphQLFloat
+    },
+    maxDistanceInRadians: {
+      description: 'This is the maxDistanceInRadians operator to specify a constraint to select the objects where the values of a geo point field is at a max distance (in radians) from the geo point specified in the $nearSphere operator.',
+      type: _graphql.GraphQLFloat
+    },
+    maxDistanceInMiles: {
+      description: 'This is the maxDistanceInMiles operator to specify a constraint to select the objects where the values of a geo point field is at a max distance (in miles) from the geo point specified in the $nearSphere operator.',
+      type: _graphql.GraphQLFloat
+    },
+    maxDistanceInKilometers: {
+      description: 'This is the maxDistanceInKilometers operator to specify a constraint to select the objects where the values of a geo point field is at a max distance (in kilometers) from the geo point specified in the $nearSphere operator.',
+      type: _graphql.GraphQLFloat
+    },
+    within: {
+      description: 'This is the within operator to specify a constraint to select the objects where the values of a geo point field is within a specified box.',
+      type: WITHIN_INPUT
+    },
+    geoWithin: {
+      description: 'This is the geoWithin operator to specify a constraint to select the objects where the values of a geo point field is within a specified polygon or sphere.',
+      type: GEO_WITHIN_INPUT
+    }
+  }
+});
+const POLYGON_WHERE_INPUT = exports.POLYGON_WHERE_INPUT = new _graphql.GraphQLInputObjectType({
+  name: 'PolygonWhereInput',
+  description: 'The PolygonWhereInput input type is used in operations that involve filtering objects by a field of type Polygon.',
+  fields: {
+    exists,
+    geoIntersects: {
+      description: 'This is the geoIntersects operator to specify a constraint to select the objects where the values of a polygon field intersect a specified point.',
+      type: GEO_INTERSECTS_INPUT
+    }
+  }
+});
+const ELEMENT = exports.ELEMENT = new _graphql.GraphQLObjectType({
+  name: 'Element',
+  description: "The Element object type is used to return array items' value.",
+  fields: {
+    value: {
+      description: 'Return the value of the element in the array',
+      type: new _graphql.GraphQLNonNull(ANY)
+    }
+  }
+});
+
+// Default static union type, we update types and resolveType function later
+let ARRAY_RESULT = exports.ARRAY_RESULT = void 0;
+const loadArrayResult = (parseGraphQLSchema, parseClassesArray) => {
+  const classTypes = parseClassesArray.filter(parseClass => parseGraphQLSchema.parseClassTypes[parseClass.className].classGraphQLOutputType ? true : false).map(parseClass => parseGraphQLSchema.parseClassTypes[parseClass.className].classGraphQLOutputType);
+  exports.ARRAY_RESULT = ARRAY_RESULT = new _graphql.GraphQLUnionType({
+    name: 'ArrayResult',
+    description: 'Use Inline Fragment on Array to get results: https://graphql.org/learn/queries/#inline-fragments',
+    types: () => [ELEMENT, ...classTypes],
+    resolveType: value => {
+      if (value.__type === 'Object' && value.className && value.objectId) {
+        if (parseGraphQLSchema.parseClassTypes[value.className]) {
+          return parseGraphQLSchema.parseClassTypes[value.className].classGraphQLOutputType.name;
+        } else {
+          return ELEMENT.name;
+        }
+      } else {
+        return ELEMENT.name;
+      }
+    }
+  });
+  parseGraphQLSchema.graphQLTypes.push(ARRAY_RESULT);
+};
+exports.loadArrayResult = loadArrayResult;
+const load = parseGraphQLSchema => {
+  parseGraphQLSchema.addGraphQLType(_GraphQLUpload.default, true);
+  parseGraphQLSchema.addGraphQLType(ANY, true);
+  parseGraphQLSchema.addGraphQLType(OBJECT, true);
+  parseGraphQLSchema.addGraphQLType(DATE, true);
+  parseGraphQLSchema.addGraphQLType(BYTES, true);
+  parseGraphQLSchema.addGraphQLType(FILE, true);
+  parseGraphQLSchema.addGraphQLType(FILE_INFO, true);
+  parseGraphQLSchema.addGraphQLType(FILE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(GEO_POINT_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(GEO_POINT, true);
+  parseGraphQLSchema.addGraphQLType(PARSE_OBJECT, true);
+  parseGraphQLSchema.addGraphQLType(READ_PREFERENCE, true);
+  parseGraphQLSchema.addGraphQLType(READ_OPTIONS_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(SEARCH_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(TEXT_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(BOX_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(WITHIN_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(CENTER_SPHERE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(GEO_WITHIN_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(GEO_INTERSECTS_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(ID_WHERE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(STRING_WHERE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(NUMBER_WHERE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(BOOLEAN_WHERE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(ARRAY_WHERE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(KEY_VALUE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(OBJECT_WHERE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(DATE_WHERE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(BYTES_WHERE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(FILE_WHERE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(GEO_POINT_WHERE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(POLYGON_WHERE_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(ELEMENT, true);
+  parseGraphQLSchema.addGraphQLType(ACL_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(USER_ACL_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(ROLE_ACL_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(PUBLIC_ACL_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(ACL, true);
+  parseGraphQLSchema.addGraphQLType(USER_ACL, true);
+  parseGraphQLSchema.addGraphQLType(ROLE_ACL, true);
+  parseGraphQLSchema.addGraphQLType(PUBLIC_ACL, true);
+  parseGraphQLSchema.addGraphQLType(SUBQUERY_INPUT, true);
+  parseGraphQLSchema.addGraphQLType(SELECT_INPUT, true);
+};
+exports.load = load;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_graphql","require","_graphqlRelay","_GraphQLUpload","_interopRequireDefault","e","__esModule","default","TypeValidationError","Error","constructor","value","type","exports","parseStringValue","parseIntValue","int","Number","isInteger","parseFloatValue","float","isNaN","parseBooleanValue","parseValue","kind","Kind","STRING","INT","FLOAT","BOOLEAN","LIST","parseListValues","values","OBJECT","parseObjectFields","fields","Array","isArray","map","reduce","object","field","name","ANY","GraphQLScalarType","description","serialize","parseLiteral","ast","parseDateIsoValue","date","Date","serializeDateIso","toISOString","parseDateIsoLiteral","DATE","__type","iso","find","BYTES","base64","parseFileValue","url","undefined","FILE","FILE_INFO","GraphQLObjectType","GraphQLNonNull","GraphQLString","FILE_INPUT","GraphQLInputObjectType","file","upload","GraphQLUpload","GEO_POINT_FIELDS","latitude","GraphQLFloat","longitude","GEO_POINT_INPUT","GEO_POINT","POLYGON_INPUT","GraphQLList","POLYGON","USER_ACL_INPUT","userId","GraphQLID","read","GraphQLBoolean","write","ROLE_ACL_INPUT","roleName","PUBLIC_ACL_INPUT","ACL_INPUT","users","roles","public","USER_ACL","ROLE_ACL","PUBLIC_ACL","ACL","resolve","p","Object","keys","forEach","rule","indexOf","push","toGlobalId","length","replace","OBJECT_ID","CLASS_NAME_ATT","GLOBAL_OR_OBJECT_ID_ATT","OBJECT_ID_ATT","CREATED_AT_ATT","UPDATED_AT_ATT","INPUT_FIELDS","CREATE_RESULT_FIELDS","objectId","createdAt","UPDATE_RESULT_FIELDS","updatedAt","PARSE_OBJECT_FIELDS","PARSE_OBJECT","GraphQLInterfaceType","SESSION_TOKEN_ATT","READ_PREFERENCE","GraphQLEnumType","PRIMARY","PRIMARY_PREFERRED","SECONDARY","SECONDARY_PREFERRED","NEAREST","READ_PREFERENCE_ATT","INCLUDE_READ_PREFERENCE_ATT","SUBQUERY_READ_PREFERENCE_ATT","READ_OPTIONS_INPUT","readPreference","includeReadPreference","subqueryReadPreference","READ_OPTIONS_ATT","WHERE_ATT","SKIP_ATT","GraphQLInt","LIMIT_ATT","COUNT_ATT","SEARCH_INPUT","term","language","caseSensitive","diacriticSensitive","TEXT_INPUT","search","BOX_INPUT","bottomLeft","upperRight","WITHIN_INPUT","box","CENTER_SPHERE_INPUT","center","distance","GEO_WITHIN_INPUT","polygon","centerSphere","GEO_INTERSECTS_INPUT","point","equalTo","notEqualTo","lessThan","lessThanOrEqualTo","greaterThan","greaterThanOrEqualTo","inOp","notIn","exists","matchesRegex","options","SUBQUERY_INPUT","className","where","assign","SELECT_INPUT","query","key","inQueryKey","notInQueryKey","ID_WHERE_INPUT","in","STRING_WHERE_INPUT","text","NUMBER_WHERE_INPUT","BOOLEAN_WHERE_INPUT","ARRAY_WHERE_INPUT","containedBy","contains","KEY_VALUE_INPUT","OBJECT_WHERE_INPUT","DATE_WHERE_INPUT","BYTES_WHERE_INPUT","FILE_WHERE_INPUT","GEO_POINT_WHERE_INPUT","nearSphere","maxDistance","maxDistanceInRadians","maxDistanceInMiles","maxDistanceInKilometers","within","geoWithin","POLYGON_WHERE_INPUT","geoIntersects","ELEMENT","ARRAY_RESULT","loadArrayResult","parseGraphQLSchema","parseClassesArray","classTypes","filter","parseClass","parseClassTypes","classGraphQLOutputType","GraphQLUnionType","types","resolveType","graphQLTypes","load","addGraphQLType"],"sources":["../../../src/GraphQL/loaders/defaultGraphQLTypes.js"],"sourcesContent":["import {\n  Kind,\n  GraphQLNonNull,\n  GraphQLScalarType,\n  GraphQLID,\n  GraphQLString,\n  GraphQLObjectType,\n  GraphQLInterfaceType,\n  GraphQLEnumType,\n  GraphQLInt,\n  GraphQLFloat,\n  GraphQLList,\n  GraphQLInputObjectType,\n  GraphQLBoolean,\n  GraphQLUnionType,\n} from 'graphql';\nimport { toGlobalId } from 'graphql-relay';\nimport GraphQLUpload from 'graphql-upload/GraphQLUpload.js';\n\nclass TypeValidationError extends Error {\n  constructor(value, type) {\n    super(`${value} is not a valid ${type}`);\n  }\n}\n\nconst parseStringValue = value => {\n  if (typeof value === 'string') {\n    return value;\n  }\n\n  throw new TypeValidationError(value, 'String');\n};\n\nconst parseIntValue = value => {\n  if (typeof value === 'string') {\n    const int = Number(value);\n    if (Number.isInteger(int)) {\n      return int;\n    }\n  }\n\n  throw new TypeValidationError(value, 'Int');\n};\n\nconst parseFloatValue = value => {\n  if (typeof value === 'string') {\n    const float = Number(value);\n    if (!isNaN(float)) {\n      return float;\n    }\n  }\n\n  throw new TypeValidationError(value, 'Float');\n};\n\nconst parseBooleanValue = value => {\n  if (typeof value === 'boolean') {\n    return value;\n  }\n\n  throw new TypeValidationError(value, 'Boolean');\n};\n\nconst parseValue = value => {\n  switch (value.kind) {\n    case Kind.STRING:\n      return parseStringValue(value.value);\n\n    case Kind.INT:\n      return parseIntValue(value.value);\n\n    case Kind.FLOAT:\n      return parseFloatValue(value.value);\n\n    case Kind.BOOLEAN:\n      return parseBooleanValue(value.value);\n\n    case Kind.LIST:\n      return parseListValues(value.values);\n\n    case Kind.OBJECT:\n      return parseObjectFields(value.fields);\n\n    default:\n      return value.value;\n  }\n};\n\nconst parseListValues = values => {\n  if (Array.isArray(values)) {\n    return values.map(value => parseValue(value));\n  }\n\n  throw new TypeValidationError(values, 'List');\n};\n\nconst parseObjectFields = fields => {\n  if (Array.isArray(fields)) {\n    return fields.reduce(\n      (object, field) => ({\n        ...object,\n        [field.name.value]: parseValue(field.value),\n      }),\n      {}\n    );\n  }\n\n  throw new TypeValidationError(fields, 'Object');\n};\n\nconst ANY = new GraphQLScalarType({\n  name: 'Any',\n  description:\n    'The Any scalar type is used in operations and types that involve any type of value.',\n  parseValue: value => value,\n  serialize: value => value,\n  parseLiteral: ast => parseValue(ast),\n});\n\nconst OBJECT = new GraphQLScalarType({\n  name: 'Object',\n  description: 'The Object scalar type is used in operations and types that involve objects.',\n  parseValue(value) {\n    if (typeof value === 'object') {\n      return value;\n    }\n\n    throw new TypeValidationError(value, 'Object');\n  },\n  serialize(value) {\n    if (typeof value === 'object') {\n      return value;\n    }\n\n    throw new TypeValidationError(value, 'Object');\n  },\n  parseLiteral(ast) {\n    if (ast.kind === Kind.OBJECT) {\n      return parseObjectFields(ast.fields);\n    }\n\n    throw new TypeValidationError(ast.kind, 'Object');\n  },\n});\n\nconst parseDateIsoValue = value => {\n  if (typeof value === 'string') {\n    const date = new Date(value);\n    if (!isNaN(date)) {\n      return date;\n    }\n  } else if (value instanceof Date) {\n    return value;\n  }\n\n  throw new TypeValidationError(value, 'Date');\n};\n\nconst serializeDateIso = value => {\n  if (typeof value === 'string') {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.toISOString();\n  }\n\n  throw new TypeValidationError(value, 'Date');\n};\n\nconst parseDateIsoLiteral = ast => {\n  if (ast.kind === Kind.STRING) {\n    return parseDateIsoValue(ast.value);\n  }\n\n  throw new TypeValidationError(ast.kind, 'Date');\n};\n\nconst DATE = new GraphQLScalarType({\n  name: 'Date',\n  description: 'The Date scalar type is used in operations and types that involve dates.',\n  parseValue(value) {\n    if (typeof value === 'string' || value instanceof Date) {\n      return {\n        __type: 'Date',\n        iso: parseDateIsoValue(value),\n      };\n    } else if (typeof value === 'object' && value.__type === 'Date' && value.iso) {\n      return {\n        __type: value.__type,\n        iso: parseDateIsoValue(value.iso),\n      };\n    }\n\n    throw new TypeValidationError(value, 'Date');\n  },\n  serialize(value) {\n    if (typeof value === 'string' || value instanceof Date) {\n      return serializeDateIso(value);\n    } else if (typeof value === 'object' && value.__type === 'Date' && value.iso) {\n      return serializeDateIso(value.iso);\n    }\n\n    throw new TypeValidationError(value, 'Date');\n  },\n  parseLiteral(ast) {\n    if (ast.kind === Kind.STRING) {\n      return {\n        __type: 'Date',\n        iso: parseDateIsoLiteral(ast),\n      };\n    } else if (ast.kind === Kind.OBJECT) {\n      const __type = ast.fields.find(field => field.name.value === '__type');\n      const iso = ast.fields.find(field => field.name.value === 'iso');\n      if (__type && __type.value && __type.value.value === 'Date' && iso) {\n        return {\n          __type: __type.value.value,\n          iso: parseDateIsoLiteral(iso.value),\n        };\n      }\n    }\n\n    throw new TypeValidationError(ast.kind, 'Date');\n  },\n});\n\nconst BYTES = new GraphQLScalarType({\n  name: 'Bytes',\n  description:\n    'The Bytes scalar type is used in operations and types that involve base 64 binary data.',\n  parseValue(value) {\n    if (typeof value === 'string') {\n      return {\n        __type: 'Bytes',\n        base64: value,\n      };\n    } else if (\n      typeof value === 'object' &&\n      value.__type === 'Bytes' &&\n      typeof value.base64 === 'string'\n    ) {\n      return value;\n    }\n\n    throw new TypeValidationError(value, 'Bytes');\n  },\n  serialize(value) {\n    if (typeof value === 'string') {\n      return value;\n    } else if (\n      typeof value === 'object' &&\n      value.__type === 'Bytes' &&\n      typeof value.base64 === 'string'\n    ) {\n      return value.base64;\n    }\n\n    throw new TypeValidationError(value, 'Bytes');\n  },\n  parseLiteral(ast) {\n    if (ast.kind === Kind.STRING) {\n      return {\n        __type: 'Bytes',\n        base64: ast.value,\n      };\n    } else if (ast.kind === Kind.OBJECT) {\n      const __type = ast.fields.find(field => field.name.value === '__type');\n      const base64 = ast.fields.find(field => field.name.value === 'base64');\n      if (\n        __type &&\n        __type.value &&\n        __type.value.value === 'Bytes' &&\n        base64 &&\n        base64.value &&\n        typeof base64.value.value === 'string'\n      ) {\n        return {\n          __type: __type.value.value,\n          base64: base64.value.value,\n        };\n      }\n    }\n\n    throw new TypeValidationError(ast.kind, 'Bytes');\n  },\n});\n\nconst parseFileValue = value => {\n  if (typeof value === 'string') {\n    return {\n      __type: 'File',\n      name: value,\n    };\n  } else if (\n    typeof value === 'object' &&\n    value.__type === 'File' &&\n    typeof value.name === 'string' &&\n    (value.url === undefined || typeof value.url === 'string')\n  ) {\n    return value;\n  }\n\n  throw new TypeValidationError(value, 'File');\n};\n\nconst FILE = new GraphQLScalarType({\n  name: 'File',\n  description: 'The File scalar type is used in operations and types that involve files.',\n  parseValue: parseFileValue,\n  serialize: value => {\n    if (typeof value === 'string') {\n      return value;\n    } else if (\n      typeof value === 'object' &&\n      value.__type === 'File' &&\n      typeof value.name === 'string' &&\n      (value.url === undefined || typeof value.url === 'string')\n    ) {\n      return value.name;\n    }\n\n    throw new TypeValidationError(value, 'File');\n  },\n  parseLiteral(ast) {\n    if (ast.kind === Kind.STRING) {\n      return parseFileValue(ast.value);\n    } else if (ast.kind === Kind.OBJECT) {\n      const __type = ast.fields.find(field => field.name.value === '__type');\n      const name = ast.fields.find(field => field.name.value === 'name');\n      const url = ast.fields.find(field => field.name.value === 'url');\n      if (__type && __type.value && name && name.value) {\n        return parseFileValue({\n          __type: __type.value.value,\n          name: name.value.value,\n          url: url && url.value ? url.value.value : undefined,\n        });\n      }\n    }\n\n    throw new TypeValidationError(ast.kind, 'File');\n  },\n});\n\nconst FILE_INFO = new GraphQLObjectType({\n  name: 'FileInfo',\n  description: 'The FileInfo object type is used to return the information about files.',\n  fields: {\n    name: {\n      description: 'This is the file name.',\n      type: new GraphQLNonNull(GraphQLString),\n    },\n    url: {\n      description: 'This is the url in which the file can be downloaded.',\n      type: new GraphQLNonNull(GraphQLString),\n    },\n  },\n});\n\nconst FILE_INPUT = new GraphQLInputObjectType({\n  name: 'FileInput',\n  description:\n    'If this field is set to null the file will be unlinked (the file will not be deleted on cloud storage).',\n  fields: {\n    file: {\n      description: 'A File Scalar can be an url or a FileInfo object.',\n      type: FILE,\n    },\n    upload: {\n      description: 'Use this field if you want to create a new file.',\n      type: GraphQLUpload,\n    },\n  },\n});\n\nconst GEO_POINT_FIELDS = {\n  latitude: {\n    description: 'This is the latitude.',\n    type: new GraphQLNonNull(GraphQLFloat),\n  },\n  longitude: {\n    description: 'This is the longitude.',\n    type: new GraphQLNonNull(GraphQLFloat),\n  },\n};\n\nconst GEO_POINT_INPUT = new GraphQLInputObjectType({\n  name: 'GeoPointInput',\n  description:\n    'The GeoPointInput type is used in operations that involve inputting fields of type geo point.',\n  fields: GEO_POINT_FIELDS,\n});\n\nconst GEO_POINT = new GraphQLObjectType({\n  name: 'GeoPoint',\n  description: 'The GeoPoint object type is used to return the information about geo point fields.',\n  fields: GEO_POINT_FIELDS,\n});\n\nconst POLYGON_INPUT = new GraphQLList(new GraphQLNonNull(GEO_POINT_INPUT));\n\nconst POLYGON = new GraphQLList(new GraphQLNonNull(GEO_POINT));\n\nconst USER_ACL_INPUT = new GraphQLInputObjectType({\n  name: 'UserACLInput',\n  description: 'Allow to manage users in ACL.',\n  fields: {\n    userId: {\n      description: 'ID of the targetted User.',\n      type: new GraphQLNonNull(GraphQLID),\n    },\n    read: {\n      description: 'Allow the user to read the current object.',\n      type: new GraphQLNonNull(GraphQLBoolean),\n    },\n    write: {\n      description: 'Allow the user to write on the current object.',\n      type: new GraphQLNonNull(GraphQLBoolean),\n    },\n  },\n});\n\nconst ROLE_ACL_INPUT = new GraphQLInputObjectType({\n  name: 'RoleACLInput',\n  description: 'Allow to manage roles in ACL.',\n  fields: {\n    roleName: {\n      description: 'Name of the targetted Role.',\n      type: new GraphQLNonNull(GraphQLString),\n    },\n    read: {\n      description: 'Allow users who are members of the role to read the current object.',\n      type: new GraphQLNonNull(GraphQLBoolean),\n    },\n    write: {\n      description: 'Allow users who are members of the role to write on the current object.',\n      type: new GraphQLNonNull(GraphQLBoolean),\n    },\n  },\n});\n\nconst PUBLIC_ACL_INPUT = new GraphQLInputObjectType({\n  name: 'PublicACLInput',\n  description: 'Allow to manage public rights.',\n  fields: {\n    read: {\n      description: 'Allow anyone to read the current object.',\n      type: new GraphQLNonNull(GraphQLBoolean),\n    },\n    write: {\n      description: 'Allow anyone to write on the current object.',\n      type: new GraphQLNonNull(GraphQLBoolean),\n    },\n  },\n});\n\nconst ACL_INPUT = new GraphQLInputObjectType({\n  name: 'ACLInput',\n  description:\n    'Allow to manage access rights. If not provided object will be publicly readable and writable',\n  fields: {\n    users: {\n      description: 'Access control list for users.',\n      type: new GraphQLList(new GraphQLNonNull(USER_ACL_INPUT)),\n    },\n    roles: {\n      description: 'Access control list for roles.',\n      type: new GraphQLList(new GraphQLNonNull(ROLE_ACL_INPUT)),\n    },\n    public: {\n      description: 'Public access control list.',\n      type: PUBLIC_ACL_INPUT,\n    },\n  },\n});\n\nconst USER_ACL = new GraphQLObjectType({\n  name: 'UserACL',\n  description:\n    'Allow to manage users in ACL. If read and write are null the users have read and write rights.',\n  fields: {\n    userId: {\n      description: 'ID of the targetted User.',\n      type: new GraphQLNonNull(GraphQLID),\n    },\n    read: {\n      description: 'Allow the user to read the current object.',\n      type: new GraphQLNonNull(GraphQLBoolean),\n    },\n    write: {\n      description: 'Allow the user to write on the current object.',\n      type: new GraphQLNonNull(GraphQLBoolean),\n    },\n  },\n});\n\nconst ROLE_ACL = new GraphQLObjectType({\n  name: 'RoleACL',\n  description:\n    'Allow to manage roles in ACL. If read and write are null the role have read and write rights.',\n  fields: {\n    roleName: {\n      description: 'Name of the targetted Role.',\n      type: new GraphQLNonNull(GraphQLID),\n    },\n    read: {\n      description: 'Allow users who are members of the role to read the current object.',\n      type: new GraphQLNonNull(GraphQLBoolean),\n    },\n    write: {\n      description: 'Allow users who are members of the role to write on the current object.',\n      type: new GraphQLNonNull(GraphQLBoolean),\n    },\n  },\n});\n\nconst PUBLIC_ACL = new GraphQLObjectType({\n  name: 'PublicACL',\n  description: 'Allow to manage public rights.',\n  fields: {\n    read: {\n      description: 'Allow anyone to read the current object.',\n      type: GraphQLBoolean,\n    },\n    write: {\n      description: 'Allow anyone to write on the current object.',\n      type: GraphQLBoolean,\n    },\n  },\n});\n\nconst ACL = new GraphQLObjectType({\n  name: 'ACL',\n  description: 'Current access control list of the current object.',\n  fields: {\n    users: {\n      description: 'Access control list for users.',\n      type: new GraphQLList(new GraphQLNonNull(USER_ACL)),\n      resolve(p) {\n        const users = [];\n        Object.keys(p).forEach(rule => {\n          if (rule !== '*' && rule.indexOf('role:') !== 0) {\n            users.push({\n              userId: toGlobalId('_User', rule),\n              read: p[rule].read ? true : false,\n              write: p[rule].write ? true : false,\n            });\n          }\n        });\n        return users.length ? users : null;\n      },\n    },\n    roles: {\n      description: 'Access control list for roles.',\n      type: new GraphQLList(new GraphQLNonNull(ROLE_ACL)),\n      resolve(p) {\n        const roles = [];\n        Object.keys(p).forEach(rule => {\n          if (rule.indexOf('role:') === 0) {\n            roles.push({\n              roleName: rule.replace('role:', ''),\n              read: p[rule].read ? true : false,\n              write: p[rule].write ? true : false,\n            });\n          }\n        });\n        return roles.length ? roles : null;\n      },\n    },\n    public: {\n      description: 'Public access control list.',\n      type: PUBLIC_ACL,\n      resolve(p) {\n        /* eslint-disable */\n        return p['*']\n          ? {\n              read: p['*'].read ? true : false,\n              write: p['*'].write ? true : false,\n            }\n          : null;\n      },\n    },\n  },\n});\n\nconst OBJECT_ID = new GraphQLNonNull(GraphQLID);\n\nconst CLASS_NAME_ATT = {\n  description: 'This is the class name of the object.',\n  type: new GraphQLNonNull(GraphQLString),\n};\n\nconst GLOBAL_OR_OBJECT_ID_ATT = {\n  description: 'This is the object id. You can use either the global or the object id.',\n  type: OBJECT_ID,\n};\n\nconst OBJECT_ID_ATT = {\n  description: 'This is the object id.',\n  type: OBJECT_ID,\n};\n\nconst CREATED_AT_ATT = {\n  description: 'This is the date in which the object was created.',\n  type: new GraphQLNonNull(DATE),\n};\n\nconst UPDATED_AT_ATT = {\n  description: 'This is the date in which the object was las updated.',\n  type: new GraphQLNonNull(DATE),\n};\n\nconst INPUT_FIELDS = {\n  ACL: {\n    type: ACL,\n  },\n};\n\nconst CREATE_RESULT_FIELDS = {\n  objectId: OBJECT_ID_ATT,\n  createdAt: CREATED_AT_ATT,\n};\n\nconst UPDATE_RESULT_FIELDS = {\n  updatedAt: UPDATED_AT_ATT,\n};\n\nconst PARSE_OBJECT_FIELDS = {\n  ...CREATE_RESULT_FIELDS,\n  ...UPDATE_RESULT_FIELDS,\n  ...INPUT_FIELDS,\n  ACL: {\n    type: new GraphQLNonNull(ACL),\n    resolve: ({ ACL }) => (ACL ? ACL : { '*': { read: true, write: true } }),\n  },\n};\n\nconst PARSE_OBJECT = new GraphQLInterfaceType({\n  name: 'ParseObject',\n  description:\n    'The ParseObject interface type is used as a base type for the auto generated object types.',\n  fields: PARSE_OBJECT_FIELDS,\n});\n\nconst SESSION_TOKEN_ATT = {\n  description: 'The current user session token.',\n  type: new GraphQLNonNull(GraphQLString),\n};\n\nconst READ_PREFERENCE = new GraphQLEnumType({\n  name: 'ReadPreference',\n  description:\n    'The ReadPreference enum type is used in queries in order to select in which database replica the operation must run.',\n  values: {\n    PRIMARY: { value: 'PRIMARY' },\n    PRIMARY_PREFERRED: { value: 'PRIMARY_PREFERRED' },\n    SECONDARY: { value: 'SECONDARY' },\n    SECONDARY_PREFERRED: { value: 'SECONDARY_PREFERRED' },\n    NEAREST: { value: 'NEAREST' },\n  },\n});\n\nconst READ_PREFERENCE_ATT = {\n  description: 'The read preference for the main query to be executed.',\n  type: READ_PREFERENCE,\n};\n\nconst INCLUDE_READ_PREFERENCE_ATT = {\n  description: 'The read preference for the queries to be executed to include fields.',\n  type: READ_PREFERENCE,\n};\n\nconst SUBQUERY_READ_PREFERENCE_ATT = {\n  description: 'The read preference for the subqueries that may be required.',\n  type: READ_PREFERENCE,\n};\n\nconst READ_OPTIONS_INPUT = new GraphQLInputObjectType({\n  name: 'ReadOptionsInput',\n  description:\n    'The ReadOptionsInputt type is used in queries in order to set the read preferences.',\n  fields: {\n    readPreference: READ_PREFERENCE_ATT,\n    includeReadPreference: INCLUDE_READ_PREFERENCE_ATT,\n    subqueryReadPreference: SUBQUERY_READ_PREFERENCE_ATT,\n  },\n});\n\nconst READ_OPTIONS_ATT = {\n  description: 'The read options for the query to be executed.',\n  type: READ_OPTIONS_INPUT,\n};\n\nconst WHERE_ATT = {\n  description: 'These are the conditions that the objects need to match in order to be found',\n  type: OBJECT,\n};\n\nconst SKIP_ATT = {\n  description: 'This is the number of objects that must be skipped to return.',\n  type: GraphQLInt,\n};\n\nconst LIMIT_ATT = {\n  description: 'This is the limit number of objects that must be returned.',\n  type: GraphQLInt,\n};\n\nconst COUNT_ATT = {\n  description:\n    'This is the total matched objecs count that is returned when the count flag is set.',\n  type: new GraphQLNonNull(GraphQLInt),\n};\n\nconst SEARCH_INPUT = new GraphQLInputObjectType({\n  name: 'SearchInput',\n  description: 'The SearchInput type is used to specifiy a search operation on a full text search.',\n  fields: {\n    term: {\n      description: 'This is the term to be searched.',\n      type: new GraphQLNonNull(GraphQLString),\n    },\n    language: {\n      description:\n        'This is the language to tetermine the list of stop words and the rules for tokenizer.',\n      type: GraphQLString,\n    },\n    caseSensitive: {\n      description: 'This is the flag to enable or disable case sensitive search.',\n      type: GraphQLBoolean,\n    },\n    diacriticSensitive: {\n      description: 'This is the flag to enable or disable diacritic sensitive search.',\n      type: GraphQLBoolean,\n    },\n  },\n});\n\nconst TEXT_INPUT = new GraphQLInputObjectType({\n  name: 'TextInput',\n  description: 'The TextInput type is used to specify a text operation on a constraint.',\n  fields: {\n    search: {\n      description: 'This is the search to be executed.',\n      type: new GraphQLNonNull(SEARCH_INPUT),\n    },\n  },\n});\n\nconst BOX_INPUT = new GraphQLInputObjectType({\n  name: 'BoxInput',\n  description: 'The BoxInput type is used to specifiy a box operation on a within geo query.',\n  fields: {\n    bottomLeft: {\n      description: 'This is the bottom left coordinates of the box.',\n      type: new GraphQLNonNull(GEO_POINT_INPUT),\n    },\n    upperRight: {\n      description: 'This is the upper right coordinates of the box.',\n      type: new GraphQLNonNull(GEO_POINT_INPUT),\n    },\n  },\n});\n\nconst WITHIN_INPUT = new GraphQLInputObjectType({\n  name: 'WithinInput',\n  description: 'The WithinInput type is used to specify a within operation on a constraint.',\n  fields: {\n    box: {\n      description: 'This is the box to be specified.',\n      type: new GraphQLNonNull(BOX_INPUT),\n    },\n  },\n});\n\nconst CENTER_SPHERE_INPUT = new GraphQLInputObjectType({\n  name: 'CenterSphereInput',\n  description:\n    'The CenterSphereInput type is used to specifiy a centerSphere operation on a geoWithin query.',\n  fields: {\n    center: {\n      description: 'This is the center of the sphere.',\n      type: new GraphQLNonNull(GEO_POINT_INPUT),\n    },\n    distance: {\n      description: 'This is the radius of the sphere.',\n      type: new GraphQLNonNull(GraphQLFloat),\n    },\n  },\n});\n\nconst GEO_WITHIN_INPUT = new GraphQLInputObjectType({\n  name: 'GeoWithinInput',\n  description: 'The GeoWithinInput type is used to specify a geoWithin operation on a constraint.',\n  fields: {\n    polygon: {\n      description: 'This is the polygon to be specified.',\n      type: POLYGON_INPUT,\n    },\n    centerSphere: {\n      description: 'This is the sphere to be specified.',\n      type: CENTER_SPHERE_INPUT,\n    },\n  },\n});\n\nconst GEO_INTERSECTS_INPUT = new GraphQLInputObjectType({\n  name: 'GeoIntersectsInput',\n  description:\n    'The GeoIntersectsInput type is used to specify a geoIntersects operation on a constraint.',\n  fields: {\n    point: {\n      description: 'This is the point to be specified.',\n      type: GEO_POINT_INPUT,\n    },\n  },\n});\n\nconst equalTo = type => ({\n  description:\n    'This is the equalTo operator to specify a constraint to select the objects where the value of a field equals to a specified value.',\n  type,\n});\n\nconst notEqualTo = type => ({\n  description:\n    'This is the notEqualTo operator to specify a constraint to select the objects where the value of a field do not equal to a specified value.',\n  type,\n});\n\nconst lessThan = type => ({\n  description:\n    'This is the lessThan operator to specify a constraint to select the objects where the value of a field is less than a specified value.',\n  type,\n});\n\nconst lessThanOrEqualTo = type => ({\n  description:\n    'This is the lessThanOrEqualTo operator to specify a constraint to select the objects where the value of a field is less than or equal to a specified value.',\n  type,\n});\n\nconst greaterThan = type => ({\n  description:\n    'This is the greaterThan operator to specify a constraint to select the objects where the value of a field is greater than a specified value.',\n  type,\n});\n\nconst greaterThanOrEqualTo = type => ({\n  description:\n    'This is the greaterThanOrEqualTo operator to specify a constraint to select the objects where the value of a field is greater than or equal to a specified value.',\n  type,\n});\n\nconst inOp = type => ({\n  description:\n    'This is the in operator to specify a constraint to select the objects where the value of a field equals any value in the specified array.',\n  type: new GraphQLList(type),\n});\n\nconst notIn = type => ({\n  description:\n    'This is the notIn operator to specify a constraint to select the objects where the value of a field do not equal any value in the specified array.',\n  type: new GraphQLList(type),\n});\n\nconst exists = {\n  description:\n    'This is the exists operator to specify a constraint to select the objects where a field exists (or do not exist).',\n  type: GraphQLBoolean,\n};\n\nconst matchesRegex = {\n  description:\n    'This is the matchesRegex operator to specify a constraint to select the objects where the value of a field matches a specified regular expression.',\n  type: GraphQLString,\n};\n\nconst options = {\n  description:\n    'This is the options operator to specify optional flags (such as \"i\" and \"m\") to be added to a matchesRegex operation in the same set of constraints.',\n  type: GraphQLString,\n};\n\nconst SUBQUERY_INPUT = new GraphQLInputObjectType({\n  name: 'SubqueryInput',\n  description: 'The SubqueryInput type is used to specify a sub query to another class.',\n  fields: {\n    className: CLASS_NAME_ATT,\n    where: Object.assign({}, WHERE_ATT, {\n      type: new GraphQLNonNull(WHERE_ATT.type),\n    }),\n  },\n});\n\nconst SELECT_INPUT = new GraphQLInputObjectType({\n  name: 'SelectInput',\n  description:\n    'The SelectInput type is used to specify an inQueryKey or a notInQueryKey operation on a constraint.',\n  fields: {\n    query: {\n      description: 'This is the subquery to be executed.',\n      type: new GraphQLNonNull(SUBQUERY_INPUT),\n    },\n    key: {\n      description:\n        'This is the key in the result of the subquery that must match (not match) the field.',\n      type: new GraphQLNonNull(GraphQLString),\n    },\n  },\n});\n\nconst inQueryKey = {\n  description:\n    'This is the inQueryKey operator to specify a constraint to select the objects where a field equals to a key in the result of a different query.',\n  type: SELECT_INPUT,\n};\n\nconst notInQueryKey = {\n  description:\n    'This is the notInQueryKey operator to specify a constraint to select the objects where a field do not equal to a key in the result of a different query.',\n  type: SELECT_INPUT,\n};\n\nconst ID_WHERE_INPUT = new GraphQLInputObjectType({\n  name: 'IdWhereInput',\n  description:\n    'The IdWhereInput input type is used in operations that involve filtering objects by an id.',\n  fields: {\n    equalTo: equalTo(GraphQLID),\n    notEqualTo: notEqualTo(GraphQLID),\n    lessThan: lessThan(GraphQLID),\n    lessThanOrEqualTo: lessThanOrEqualTo(GraphQLID),\n    greaterThan: greaterThan(GraphQLID),\n    greaterThanOrEqualTo: greaterThanOrEqualTo(GraphQLID),\n    in: inOp(GraphQLID),\n    notIn: notIn(GraphQLID),\n    exists,\n    inQueryKey,\n    notInQueryKey,\n  },\n});\n\nconst STRING_WHERE_INPUT = new GraphQLInputObjectType({\n  name: 'StringWhereInput',\n  description:\n    'The StringWhereInput input type is used in operations that involve filtering objects by a field of type String.',\n  fields: {\n    equalTo: equalTo(GraphQLString),\n    notEqualTo: notEqualTo(GraphQLString),\n    lessThan: lessThan(GraphQLString),\n    lessThanOrEqualTo: lessThanOrEqualTo(GraphQLString),\n    greaterThan: greaterThan(GraphQLString),\n    greaterThanOrEqualTo: greaterThanOrEqualTo(GraphQLString),\n    in: inOp(GraphQLString),\n    notIn: notIn(GraphQLString),\n    exists,\n    matchesRegex,\n    options,\n    text: {\n      description: 'This is the $text operator to specify a full text search constraint.',\n      type: TEXT_INPUT,\n    },\n    inQueryKey,\n    notInQueryKey,\n  },\n});\n\nconst NUMBER_WHERE_INPUT = new GraphQLInputObjectType({\n  name: 'NumberWhereInput',\n  description:\n    'The NumberWhereInput input type is used in operations that involve filtering objects by a field of type Number.',\n  fields: {\n    equalTo: equalTo(GraphQLFloat),\n    notEqualTo: notEqualTo(GraphQLFloat),\n    lessThan: lessThan(GraphQLFloat),\n    lessThanOrEqualTo: lessThanOrEqualTo(GraphQLFloat),\n    greaterThan: greaterThan(GraphQLFloat),\n    greaterThanOrEqualTo: greaterThanOrEqualTo(GraphQLFloat),\n    in: inOp(GraphQLFloat),\n    notIn: notIn(GraphQLFloat),\n    exists,\n    inQueryKey,\n    notInQueryKey,\n  },\n});\n\nconst BOOLEAN_WHERE_INPUT = new GraphQLInputObjectType({\n  name: 'BooleanWhereInput',\n  description:\n    'The BooleanWhereInput input type is used in operations that involve filtering objects by a field of type Boolean.',\n  fields: {\n    equalTo: equalTo(GraphQLBoolean),\n    notEqualTo: notEqualTo(GraphQLBoolean),\n    exists,\n    inQueryKey,\n    notInQueryKey,\n  },\n});\n\nconst ARRAY_WHERE_INPUT = new GraphQLInputObjectType({\n  name: 'ArrayWhereInput',\n  description:\n    'The ArrayWhereInput input type is used in operations that involve filtering objects by a field of type Array.',\n  fields: {\n    equalTo: equalTo(ANY),\n    notEqualTo: notEqualTo(ANY),\n    lessThan: lessThan(ANY),\n    lessThanOrEqualTo: lessThanOrEqualTo(ANY),\n    greaterThan: greaterThan(ANY),\n    greaterThanOrEqualTo: greaterThanOrEqualTo(ANY),\n    in: inOp(ANY),\n    notIn: notIn(ANY),\n    exists,\n    containedBy: {\n      description:\n        'This is the containedBy operator to specify a constraint to select the objects where the values of an array field is contained by another specified array.',\n      type: new GraphQLList(ANY),\n    },\n    contains: {\n      description:\n        'This is the contains operator to specify a constraint to select the objects where the values of an array field contain all elements of another specified array.',\n      type: new GraphQLList(ANY),\n    },\n    inQueryKey,\n    notInQueryKey,\n  },\n});\n\nconst KEY_VALUE_INPUT = new GraphQLInputObjectType({\n  name: 'KeyValueInput',\n  description: 'An entry from an object, i.e., a pair of key and value.',\n  fields: {\n    key: {\n      description: 'The key used to retrieve the value of this entry.',\n      type: new GraphQLNonNull(GraphQLString),\n    },\n    value: {\n      description: 'The value of the entry. Could be any type of scalar data.',\n      type: new GraphQLNonNull(ANY),\n    },\n  },\n});\n\nconst OBJECT_WHERE_INPUT = new GraphQLInputObjectType({\n  name: 'ObjectWhereInput',\n  description:\n    'The ObjectWhereInput input type is used in operations that involve filtering result by a field of type Object.',\n  fields: {\n    equalTo: equalTo(KEY_VALUE_INPUT),\n    notEqualTo: notEqualTo(KEY_VALUE_INPUT),\n    in: inOp(KEY_VALUE_INPUT),\n    notIn: notIn(KEY_VALUE_INPUT),\n    lessThan: lessThan(KEY_VALUE_INPUT),\n    lessThanOrEqualTo: lessThanOrEqualTo(KEY_VALUE_INPUT),\n    greaterThan: greaterThan(KEY_VALUE_INPUT),\n    greaterThanOrEqualTo: greaterThanOrEqualTo(KEY_VALUE_INPUT),\n    exists,\n    inQueryKey,\n    notInQueryKey,\n  },\n});\n\nconst DATE_WHERE_INPUT = new GraphQLInputObjectType({\n  name: 'DateWhereInput',\n  description:\n    'The DateWhereInput input type is used in operations that involve filtering objects by a field of type Date.',\n  fields: {\n    equalTo: equalTo(DATE),\n    notEqualTo: notEqualTo(DATE),\n    lessThan: lessThan(DATE),\n    lessThanOrEqualTo: lessThanOrEqualTo(DATE),\n    greaterThan: greaterThan(DATE),\n    greaterThanOrEqualTo: greaterThanOrEqualTo(DATE),\n    in: inOp(DATE),\n    notIn: notIn(DATE),\n    exists,\n    inQueryKey,\n    notInQueryKey,\n  },\n});\n\nconst BYTES_WHERE_INPUT = new GraphQLInputObjectType({\n  name: 'BytesWhereInput',\n  description:\n    'The BytesWhereInput input type is used in operations that involve filtering objects by a field of type Bytes.',\n  fields: {\n    equalTo: equalTo(BYTES),\n    notEqualTo: notEqualTo(BYTES),\n    lessThan: lessThan(BYTES),\n    lessThanOrEqualTo: lessThanOrEqualTo(BYTES),\n    greaterThan: greaterThan(BYTES),\n    greaterThanOrEqualTo: greaterThanOrEqualTo(BYTES),\n    in: inOp(BYTES),\n    notIn: notIn(BYTES),\n    exists,\n    inQueryKey,\n    notInQueryKey,\n  },\n});\n\nconst FILE_WHERE_INPUT = new GraphQLInputObjectType({\n  name: 'FileWhereInput',\n  description:\n    'The FileWhereInput input type is used in operations that involve filtering objects by a field of type File.',\n  fields: {\n    equalTo: equalTo(FILE),\n    notEqualTo: notEqualTo(FILE),\n    lessThan: lessThan(FILE),\n    lessThanOrEqualTo: lessThanOrEqualTo(FILE),\n    greaterThan: greaterThan(FILE),\n    greaterThanOrEqualTo: greaterThanOrEqualTo(FILE),\n    in: inOp(FILE),\n    notIn: notIn(FILE),\n    exists,\n    matchesRegex,\n    options,\n    inQueryKey,\n    notInQueryKey,\n  },\n});\n\nconst GEO_POINT_WHERE_INPUT = new GraphQLInputObjectType({\n  name: 'GeoPointWhereInput',\n  description:\n    'The GeoPointWhereInput input type is used in operations that involve filtering objects by a field of type GeoPoint.',\n  fields: {\n    exists,\n    nearSphere: {\n      description:\n        'This is the nearSphere operator to specify a constraint to select the objects where the values of a geo point field is near to another geo point.',\n      type: GEO_POINT_INPUT,\n    },\n    maxDistance: {\n      description:\n        'This is the maxDistance operator to specify a constraint to select the objects where the values of a geo point field is at a max distance (in radians) from the geo point specified in the $nearSphere operator.',\n      type: GraphQLFloat,\n    },\n    maxDistanceInRadians: {\n      description:\n        'This is the maxDistanceInRadians operator to specify a constraint to select the objects where the values of a geo point field is at a max distance (in radians) from the geo point specified in the $nearSphere operator.',\n      type: GraphQLFloat,\n    },\n    maxDistanceInMiles: {\n      description:\n        'This is the maxDistanceInMiles operator to specify a constraint to select the objects where the values of a geo point field is at a max distance (in miles) from the geo point specified in the $nearSphere operator.',\n      type: GraphQLFloat,\n    },\n    maxDistanceInKilometers: {\n      description:\n        'This is the maxDistanceInKilometers operator to specify a constraint to select the objects where the values of a geo point field is at a max distance (in kilometers) from the geo point specified in the $nearSphere operator.',\n      type: GraphQLFloat,\n    },\n    within: {\n      description:\n        'This is the within operator to specify a constraint to select the objects where the values of a geo point field is within a specified box.',\n      type: WITHIN_INPUT,\n    },\n    geoWithin: {\n      description:\n        'This is the geoWithin operator to specify a constraint to select the objects where the values of a geo point field is within a specified polygon or sphere.',\n      type: GEO_WITHIN_INPUT,\n    },\n  },\n});\n\nconst POLYGON_WHERE_INPUT = new GraphQLInputObjectType({\n  name: 'PolygonWhereInput',\n  description:\n    'The PolygonWhereInput input type is used in operations that involve filtering objects by a field of type Polygon.',\n  fields: {\n    exists,\n    geoIntersects: {\n      description:\n        'This is the geoIntersects operator to specify a constraint to select the objects where the values of a polygon field intersect a specified point.',\n      type: GEO_INTERSECTS_INPUT,\n    },\n  },\n});\n\nconst ELEMENT = new GraphQLObjectType({\n  name: 'Element',\n  description: \"The Element object type is used to return array items' value.\",\n  fields: {\n    value: {\n      description: 'Return the value of the element in the array',\n      type: new GraphQLNonNull(ANY),\n    },\n  },\n});\n\n// Default static union type, we update types and resolveType function later\nlet ARRAY_RESULT;\n\nconst loadArrayResult = (parseGraphQLSchema, parseClassesArray) => {\n  const classTypes = parseClassesArray\n    .filter(parseClass =>\n      parseGraphQLSchema.parseClassTypes[parseClass.className].classGraphQLOutputType ? true : false\n    )\n    .map(\n      parseClass => parseGraphQLSchema.parseClassTypes[parseClass.className].classGraphQLOutputType\n    );\n  ARRAY_RESULT = new GraphQLUnionType({\n    name: 'ArrayResult',\n    description:\n      'Use Inline Fragment on Array to get results: https://graphql.org/learn/queries/#inline-fragments',\n    types: () => [ELEMENT, ...classTypes],\n    resolveType: value => {\n      if (value.__type === 'Object' && value.className && value.objectId) {\n        if (parseGraphQLSchema.parseClassTypes[value.className]) {\n          return parseGraphQLSchema.parseClassTypes[value.className].classGraphQLOutputType.name;\n        } else {\n          return ELEMENT.name;\n        }\n      } else {\n        return ELEMENT.name;\n      }\n    },\n  });\n  parseGraphQLSchema.graphQLTypes.push(ARRAY_RESULT);\n};\n\nconst load = parseGraphQLSchema => {\n  parseGraphQLSchema.addGraphQLType(GraphQLUpload, true);\n  parseGraphQLSchema.addGraphQLType(ANY, true);\n  parseGraphQLSchema.addGraphQLType(OBJECT, true);\n  parseGraphQLSchema.addGraphQLType(DATE, true);\n  parseGraphQLSchema.addGraphQLType(BYTES, true);\n  parseGraphQLSchema.addGraphQLType(FILE, true);\n  parseGraphQLSchema.addGraphQLType(FILE_INFO, true);\n  parseGraphQLSchema.addGraphQLType(FILE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(GEO_POINT_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(GEO_POINT, true);\n  parseGraphQLSchema.addGraphQLType(PARSE_OBJECT, true);\n  parseGraphQLSchema.addGraphQLType(READ_PREFERENCE, true);\n  parseGraphQLSchema.addGraphQLType(READ_OPTIONS_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(SEARCH_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(TEXT_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(BOX_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(WITHIN_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(CENTER_SPHERE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(GEO_WITHIN_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(GEO_INTERSECTS_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(ID_WHERE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(STRING_WHERE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(NUMBER_WHERE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(BOOLEAN_WHERE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(ARRAY_WHERE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(KEY_VALUE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(OBJECT_WHERE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(DATE_WHERE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(BYTES_WHERE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(FILE_WHERE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(GEO_POINT_WHERE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(POLYGON_WHERE_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(ELEMENT, true);\n  parseGraphQLSchema.addGraphQLType(ACL_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(USER_ACL_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(ROLE_ACL_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(PUBLIC_ACL_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(ACL, true);\n  parseGraphQLSchema.addGraphQLType(USER_ACL, true);\n  parseGraphQLSchema.addGraphQLType(ROLE_ACL, true);\n  parseGraphQLSchema.addGraphQLType(PUBLIC_ACL, true);\n  parseGraphQLSchema.addGraphQLType(SUBQUERY_INPUT, true);\n  parseGraphQLSchema.addGraphQLType(SELECT_INPUT, true);\n};\n\nexport {\n  GraphQLUpload,\n  TypeValidationError,\n  parseStringValue,\n  parseIntValue,\n  parseFloatValue,\n  parseBooleanValue,\n  parseValue,\n  parseListValues,\n  parseObjectFields,\n  ANY,\n  OBJECT,\n  parseDateIsoValue,\n  serializeDateIso,\n  DATE,\n  BYTES,\n  parseFileValue,\n  SUBQUERY_INPUT,\n  SELECT_INPUT,\n  FILE,\n  FILE_INFO,\n  FILE_INPUT,\n  GEO_POINT_FIELDS,\n  GEO_POINT_INPUT,\n  GEO_POINT,\n  POLYGON_INPUT,\n  POLYGON,\n  OBJECT_ID,\n  CLASS_NAME_ATT,\n  GLOBAL_OR_OBJECT_ID_ATT,\n  OBJECT_ID_ATT,\n  UPDATED_AT_ATT,\n  CREATED_AT_ATT,\n  INPUT_FIELDS,\n  CREATE_RESULT_FIELDS,\n  UPDATE_RESULT_FIELDS,\n  PARSE_OBJECT_FIELDS,\n  PARSE_OBJECT,\n  SESSION_TOKEN_ATT,\n  READ_PREFERENCE,\n  READ_PREFERENCE_ATT,\n  INCLUDE_READ_PREFERENCE_ATT,\n  SUBQUERY_READ_PREFERENCE_ATT,\n  READ_OPTIONS_INPUT,\n  READ_OPTIONS_ATT,\n  WHERE_ATT,\n  SKIP_ATT,\n  LIMIT_ATT,\n  COUNT_ATT,\n  SEARCH_INPUT,\n  TEXT_INPUT,\n  BOX_INPUT,\n  WITHIN_INPUT,\n  CENTER_SPHERE_INPUT,\n  GEO_WITHIN_INPUT,\n  GEO_INTERSECTS_INPUT,\n  equalTo,\n  notEqualTo,\n  lessThan,\n  lessThanOrEqualTo,\n  greaterThan,\n  greaterThanOrEqualTo,\n  inOp,\n  notIn,\n  exists,\n  matchesRegex,\n  options,\n  inQueryKey,\n  notInQueryKey,\n  ID_WHERE_INPUT,\n  STRING_WHERE_INPUT,\n  NUMBER_WHERE_INPUT,\n  BOOLEAN_WHERE_INPUT,\n  ARRAY_WHERE_INPUT,\n  KEY_VALUE_INPUT,\n  OBJECT_WHERE_INPUT,\n  DATE_WHERE_INPUT,\n  BYTES_WHERE_INPUT,\n  FILE_WHERE_INPUT,\n  GEO_POINT_WHERE_INPUT,\n  POLYGON_WHERE_INPUT,\n  ARRAY_RESULT,\n  ELEMENT,\n  ACL_INPUT,\n  USER_ACL_INPUT,\n  ROLE_ACL_INPUT,\n  PUBLIC_ACL_INPUT,\n  ACL,\n  USER_ACL,\n  ROLE_ACL,\n  PUBLIC_ACL,\n  load,\n  loadArrayResult,\n};\n"],"mappings":"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","ignoreList":[]}