local l_Parent_0 = script.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local _ = require(l_Parent_1.Parent.LuauPolyfill);
local _ = require(l_Parent_1.error);
local v4 = require(l_Parent_0.tokenKind);
local l_Location_0 = require(l_Parent_0.ast).Location;
local l_Source_0 = require(l_Parent_0.source).Source;
local v7 = require(l_Parent_0.lexer);
local l_Lexer_0 = v7.Lexer;
local l_isPunctuatorTokenKind_0 = v7.isPunctuatorTokenKind;
local l_TokenKind_0 = v4.TokenKind;
local l_DirectiveLocation_0 = require(l_Parent_0.directiveLocation).DirectiveLocation;
local l_Kind_0 = require(l_Parent_0.kinds).Kind;
local l_syntaxError_0 = require(script.Parent.Parent.error.syntaxError).syntaxError;
local v14 = nil;
local v15 = nil;
local v16 = {};
v16.__index = v16;
local function v19(v17, v18)
    return v16.new(v17, v18):parseDocument();
end;
local function v24(v20, v21)
    local v22 = v16.new(v20, v21);
    v22:expectToken(l_TokenKind_0.SOF);
    local v23 = v22:parseValueLiteral(false);
    v22:expectToken(l_TokenKind_0.EOF);
    return v23;
end;
local function v29(v25, v26)
    local v27 = v16.new(v25, v26);
    v27:expectToken(l_TokenKind_0.SOF);
    local v28 = v27:parseTypeReference();
    v27:expectToken(l_TokenKind_0.EOF);
    return v28;
end;
v16.new = function(v30, v31)
    local _ = nil;
    return (setmetatable({
        _lexer = l_Lexer_0.new(if typeof(v30) == "string" then l_Source_0.new(v30) else v30),
        _options = v31
    }, v16));
end;
v16.parseName = function(v33)
    local v34 = v33:expectToken(l_TokenKind_0.NAME);
    return {
        kind = l_Kind_0.NAME,
        value = v34.value,
        loc = v33:loc(v34)
    };
end;
v16.parseDocument = function(v35)
    return {
        kind = l_Kind_0.DOCUMENT,
        definitions = v35:many(l_TokenKind_0.SOF, v35.parseDefinition, l_TokenKind_0.EOF),
        loc = v35:loc(v35._lexer.token)
    };
end;
v16.parseDefinition = function(v36)
    if not v36:peek(l_TokenKind_0.NAME) then
        if not v36:peek(l_TokenKind_0.BRACE_L) then
            if v36:peekDescription() then
                return v36:parseTypeSystemDefinition();
            end;
        else
            return v36:parseOperationDefinition();
        end;
    else
        local l_value_0 = v36._lexer.token.value;
        if not (l_value_0 ~= "query" and l_value_0 ~= "mutation") or l_value_0 == "subscription" then
            return v36:parseOperationDefinition();
        elseif l_value_0 == "fragment" then
            return v36:parseFragmentDefinition();
        elseif not ((((((l_value_0 ~= "schema" and l_value_0 ~= "scalar") and l_value_0 ~= "type") and l_value_0 ~= "interface") and l_value_0 ~= "union") and l_value_0 ~= "enum") and l_value_0 ~= "input") or l_value_0 == "directive" then
            return v36:parseTypeSystemDefinition();
        elseif l_value_0 == "extend" then
            return v36:parseTypeSystemExtension();
        end;
    end;
    error(v36:unexpected());
end;
v16.parseOperationDefinition = function(v38)
    local l_token_0 = v38._lexer.token;
    if not v38:peek(l_TokenKind_0.BRACE_L) then
        local v40 = v38:parseOperationType();
        local v41 = nil;
        if v38:peek(l_TokenKind_0.NAME) then
            v41 = v38:parseName();
        end;
        return {
            kind = l_Kind_0.OPERATION_DEFINITION,
            operation = v40,
            name = v41,
            variableDefinitions = v38:parseVariableDefinitions(),
            directives = v38:parseDirectives(false),
            selectionSet = v38:parseSelectionSet(),
            loc = v38:loc(l_token_0)
        };
    else
        return {
            kind = l_Kind_0.OPERATION_DEFINITION,
            operation = "query",
            name = nil,
            variableDefinitions = {},
            directives = {},
            selectionSet = v38:parseSelectionSet(),
            loc = v38:loc(l_token_0)
        };
    end;
end;
v16.parseOperationType = function(v42)
    local v43 = v42:expectToken(l_TokenKind_0.NAME);
    if v43.value == "query" then
        return "query";
    elseif v43.value == "mutation" then
        return "mutation";
    elseif v43.value == "subscription" then
        return "subscription";
    else
        error(v42:unexpected(v43));
        return ;
    end;
end;
v16.parseVariableDefinitions = function(v44)
    return v44:optionalMany(l_TokenKind_0.PAREN_L, v44.parseVariableDefinition, l_TokenKind_0.PAREN_R);
end;
v16.parseVariableDefinition = function(v45)
    local l_token_1 = v45._lexer.token;
    local v47 = v45:parseVariable();
    v45:expectToken(l_TokenKind_0.COLON);
    return {
        kind = l_Kind_0.VARIABLE_DEFINITION,
        variable = v47,
        type = v45:parseTypeReference(),
        defaultValue = if not v45:expectOptionalToken(l_TokenKind_0.EQUALS) then nil else v45:parseValueLiteral(true),
        directives = v45:parseDirectives(true),
        loc = v45:loc(l_token_1)
    };
end;
v16.parseVariable = function(v48)
    local l_token_2 = v48._lexer.token;
    v48:expectToken(l_TokenKind_0.DOLLAR);
    return {
        kind = l_Kind_0.VARIABLE,
        name = v48:parseName(),
        loc = v48:loc(l_token_2)
    };
end;
v16.parseSelectionSet = function(v50)
    return {
        kind = l_Kind_0.SELECTION_SET,
        selections = v50:many(l_TokenKind_0.BRACE_L, v50.parseSelection, l_TokenKind_0.BRACE_R),
        loc = v50:loc(v50._lexer.token)
    };
end;
v16.parseSelection = function(v51)
    if not v51:peek(l_TokenKind_0.SPREAD) then
        return v51:parseField();
    else
        return v51:parseFragment();
    end;
end;
v16.parseField = function(v52)
    local l_token_3 = v52._lexer.token;
    local v54 = v52:parseName();
    local v55 = nil;
    local v56 = nil;
    if not v52:expectOptionalToken(l_TokenKind_0.COLON) then
        v56 = v54;
    else
        v55 = v54;
        v56 = v52:parseName();
    end;
    return {
        kind = l_Kind_0.FIELD,
        alias = v55,
        name = v56,
        arguments = v52:parseArguments(false),
        directives = v52:parseDirectives(false),
        selectionSet = not not v52:peek(l_TokenKind_0.BRACE_L) and v52:parseSelectionSet() or nil,
        loc = v52:loc(l_token_3)
    };
end;
v16.parseArguments = function(v57, v58)
    local _ = nil;
    return v57:optionalMany(l_TokenKind_0.PAREN_L, if not v58 then v57.parseArgument else v57.parseConstArgument, l_TokenKind_0.PAREN_R);
end;
v16.parseArgument = function(v60)
    local l_token_4 = v60._lexer.token;
    local v62 = v60:parseName();
    v60:expectToken(l_TokenKind_0.COLON);
    return {
        kind = l_Kind_0.ARGUMENT,
        name = v62,
        value = v60:parseValueLiteral(false),
        loc = v60:loc(l_token_4)
    };
end;
v16.parseConstArgument = function(v63)
    local l_token_5 = v63._lexer.token;
    local v65 = v63:parseName();
    v63:expectToken(l_TokenKind_0.COLON);
    return {
        kind = l_Kind_0.ARGUMENT,
        name = v65,
        value = v63:parseValueLiteral(true),
        loc = v63:loc(l_token_5)
    };
end;
v16.parseFragment = function(v66)
    local l_token_6 = v66._lexer.token;
    v66:expectToken(l_TokenKind_0.SPREAD);
    local v68 = v66:expectOptionalKeyword("on");
    if v68 or not v66:peek(l_TokenKind_0.NAME) then
        return {
            kind = l_Kind_0.INLINE_FRAGMENT,
            typeCondition = if not v68 then nil else v66:parseNamedType(),
            directives = v66:parseDirectives(false),
            selectionSet = v66:parseSelectionSet(),
            loc = v66:loc(l_token_6)
        };
    else
        return {
            kind = l_Kind_0.FRAGMENT_SPREAD,
            name = v66:parseFragmentName(),
            directives = v66:parseDirectives(false),
            loc = v66:loc(l_token_6)
        };
    end;
end;
v16.parseFragmentDefinition = function(v69)
    local l_token_7 = v69._lexer.token;
    v69:expectKeyword("fragment");
    if (v69._options and v69._options.experimentalFragmentVariables) == true then
        local v71 = v69:parseFragmentName();
        local v72 = v69:parseVariableDefinitions();
        v69:expectKeyword("on");
        return {
            kind = l_Kind_0.FRAGMENT_DEFINITION,
            name = v71,
            variableDefinitions = v72,
            typeCondition = v69:parseNamedType(),
            directives = v69:parseDirectives(false),
            selectionSet = v69:parseSelectionSet(),
            loc = v69:loc(l_token_7)
        };
    else
        local v73 = v69:parseFragmentName();
        v69:expectKeyword("on");
        return {
            kind = l_Kind_0.FRAGMENT_DEFINITION,
            name = v73,
            typeCondition = v69:parseNamedType(),
            directives = v69:parseDirectives(false),
            selectionSet = v69:parseSelectionSet(),
            loc = v69:loc(l_token_7)
        };
    end;
end;
v16.parseFragmentName = function(v74)
    if v74._lexer.token.value == "on" then
        error(v74:unexpected());
    end;
    return v74:parseName();
end;
v16.parseValueLiteral = function(v75, v76)
    local l_token_8 = v75._lexer.token;
    local l_kind_0 = l_token_8.kind;
    if l_kind_0 == l_TokenKind_0.BRACKET_L then
        return v75:parseList(v76);
    elseif l_kind_0 == l_TokenKind_0.BRACE_L then
        return v75:parseObject(v76);
    elseif l_kind_0 == l_TokenKind_0.INT then
        v75._lexer:advance();
        return {
            kind = l_Kind_0.INT,
            value = l_token_8.value,
            loc = v75:loc(l_token_8)
        };
    elseif l_kind_0 == l_TokenKind_0.FLOAT then
        v75._lexer:advance();
        return {
            kind = l_Kind_0.FLOAT,
            value = l_token_8.value,
            loc = v75:loc(l_token_8)
        };
    elseif not (l_kind_0 ~= l_TokenKind_0.STRING) or l_kind_0 == l_TokenKind_0.BLOCK_STRING then
        return v75:parseStringLiteral();
    elseif l_kind_0 == l_TokenKind_0.NAME then
        v75._lexer:advance();
        local l_value_1 = l_token_8.value;
        if l_value_1 == "true" then
            return {
                kind = l_Kind_0.BOOLEAN,
                value = true,
                loc = v75:loc(l_token_8)
            };
        elseif l_value_1 == "false" then
            return {
                kind = l_Kind_0.BOOLEAN,
                value = false,
                loc = v75:loc(l_token_8)
            };
        elseif l_value_1 == "null" then
            return {
                kind = l_Kind_0.NULL,
                loc = v75:loc(l_token_8)
            };
        else
            return {
                kind = l_Kind_0.ENUM,
                value = l_value_1,
                loc = v75:loc(l_token_8)
            };
        end;
    elseif not (l_kind_0 == l_TokenKind_0.DOLLAR) or v76 then
        error(v75:unexpected());
        return ;
    else
        return v75:parseVariable();
    end;
end;
v16.parseStringLiteral = function(v80)
    local l_token_9 = v80._lexer.token;
    v80._lexer:advance();
    return {
        kind = l_Kind_0.STRING,
        value = l_token_9.value,
        block = l_token_9.kind == l_TokenKind_0.BLOCK_STRING,
        loc = v80:loc(l_token_9)
    };
end;
v16.parseList = function(v82, v83)
    return {
        kind = l_Kind_0.LIST,
        values = v82:any(l_TokenKind_0.BRACKET_L, function()
            return v82:parseValueLiteral(v83);
        end, l_TokenKind_0.BRACKET_R),
        loc = v82:loc(v82._lexer.token)
    };
end;
v16.parseObject = function(v84, v85)
    return {
        kind = l_Kind_0.OBJECT,
        fields = v84:any(l_TokenKind_0.BRACE_L, function()
            return v84:parseObjectField(v85);
        end, l_TokenKind_0.BRACE_R),
        loc = v84:loc(v84._lexer.token)
    };
end;
v16.parseObjectField = function(v86, v87)
    local l_token_10 = v86._lexer.token;
    local v89 = v86:parseName();
    v86:expectToken(l_TokenKind_0.COLON);
    return {
        kind = l_Kind_0.OBJECT_FIELD,
        name = v89,
        value = v86:parseValueLiteral(v87),
        loc = v86:loc(l_token_10)
    };
end;
v16.parseDirectives = function(v90, v91)
    local v92 = {};
    while v90:peek(l_TokenKind_0.AT) do
        table.insert(v92, v90:parseDirective(v91));
    end;
    return v92;
end;
v16.parseDirective = function(v93, v94)
    local l_token_11 = v93._lexer.token;
    v93:expectToken(l_TokenKind_0.AT);
    return {
        kind = l_Kind_0.DIRECTIVE,
        name = v93:parseName(),
        arguments = v93:parseArguments(v94),
        loc = v93:loc(l_token_11)
    };
end;
v16.parseTypeReference = function(v96)
    local l_token_12 = v96._lexer.token;
    local v98 = nil;
    if not v96:expectOptionalToken(l_TokenKind_0.BRACKET_L) then
        v98 = v96:parseNamedType();
    else
        local v99 = v96:parseTypeReference();
        v96:expectToken(l_TokenKind_0.BRACKET_R);
        v98 = {
            kind = l_Kind_0.LIST_TYPE,
            type = v99,
            loc = v96:loc(l_token_12)
        };
    end;
    if not v96:expectOptionalToken(l_TokenKind_0.BANG) then
        return v98;
    else
        return {
            kind = l_Kind_0.NON_NULL_TYPE,
            type = v98,
            loc = v96:loc(l_token_12)
        };
    end;
end;
v16.parseNamedType = function(v100)
    return {
        kind = l_Kind_0.NAMED_TYPE,
        name = v100:parseName(),
        loc = v100:loc(v100._lexer.token)
    };
end;
v16.parseTypeSystemDefinition = function(v101)
    local v102 = if not v101:peekDescription() then v101._lexer.token else v101._lexer:lookahead();
    if v102.kind == l_TokenKind_0.NAME then
        local l_value_2 = v102.value;
        if l_value_2 == "schema" then
            return v101:parseSchemaDefinition();
        elseif l_value_2 == "scalar" then
            return v101:parseScalarTypeDefinition();
        elseif l_value_2 == "type" then
            return v101:parseObjectTypeDefinition();
        elseif l_value_2 == "interface" then
            return v101:parseInterfaceTypeDefinition();
        elseif l_value_2 == "union" then
            return v101:parseUnionTypeDefinition();
        elseif l_value_2 == "enum" then
            return v101:parseEnumTypeDefinition();
        elseif l_value_2 == "input" then
            return v101:parseInputObjectTypeDefinition();
        elseif l_value_2 == "directive" then
            return v101:parseDirectiveDefinition();
        end;
    end;
    error(v101:unexpected(v102));
end;
v16.peekDescription = function(v104)
    return v104:peek(l_TokenKind_0.STRING) or v104:peek(l_TokenKind_0.BLOCK_STRING);
end;
v16.parseDescription = function(v105)
    if not v105:peekDescription() then
        return ;
    else
        return v105:parseStringLiteral();
    end;
end;
v16.parseSchemaDefinition = function(v106)
    local l_token_13 = v106._lexer.token;
    local v108 = v106:parseDescription();
    v106:expectKeyword("schema");
    return {
        kind = l_Kind_0.SCHEMA_DEFINITION,
        description = v108,
        directives = v106:parseDirectives(true),
        operationTypes = v106:many(l_TokenKind_0.BRACE_L, v106.parseOperationTypeDefinition, l_TokenKind_0.BRACE_R),
        loc = v106:loc(l_token_13)
    };
end;
v16.parseOperationTypeDefinition = function(v109)
    local l_token_14 = v109._lexer.token;
    local v111 = v109:parseOperationType();
    v109:expectToken(l_TokenKind_0.COLON);
    return {
        kind = l_Kind_0.OPERATION_TYPE_DEFINITION,
        operation = v111,
        type = v109:parseNamedType(),
        loc = v109:loc(l_token_14)
    };
end;
v16.parseScalarTypeDefinition = function(v112)
    local l_token_15 = v112._lexer.token;
    local v114 = v112:parseDescription();
    v112:expectKeyword("scalar");
    return {
        kind = l_Kind_0.SCALAR_TYPE_DEFINITION,
        description = v114,
        name = v112:parseName(),
        directives = v112:parseDirectives(true),
        loc = v112:loc(l_token_15)
    };
end;
v16.parseObjectTypeDefinition = function(v115)
    local l_token_16 = v115._lexer.token;
    local v117 = v115:parseDescription();
    v115:expectKeyword("type");
    return {
        kind = l_Kind_0.OBJECT_TYPE_DEFINITION,
        description = v117,
        name = v115:parseName(),
        interfaces = v115:parseImplementsInterfaces(),
        directives = v115:parseDirectives(true),
        fields = v115:parseFieldsDefinition(),
        loc = v115:loc(l_token_16)
    };
end;
v16.parseImplementsInterfaces = function(v118)
    if not v118:expectOptionalKeyword("implements") then
        return {};
    else
        return v118:delimitedMany(l_TokenKind_0.AMP, v118.parseNamedType);
    end;
end;
v16.parseFieldsDefinition = function(v119)
    return v119:optionalMany(l_TokenKind_0.BRACE_L, v119.parseFieldDefinition, l_TokenKind_0.BRACE_R);
end;
v16.parseFieldDefinition = function(v120)
    local l_token_17 = v120._lexer.token;
    local v122 = v120:parseDescription();
    local v123 = v120:parseName();
    local v124 = v120:parseArgumentDefs();
    v120:expectToken(l_TokenKind_0.COLON);
    return {
        kind = l_Kind_0.FIELD_DEFINITION,
        description = v122,
        name = v123,
        arguments = v124,
        type = v120:parseTypeReference(),
        directives = v120:parseDirectives(true),
        loc = v120:loc(l_token_17)
    };
end;
v16.parseArgumentDefs = function(v125)
    return v125:optionalMany(l_TokenKind_0.PAREN_L, v125.parseInputValueDef, l_TokenKind_0.PAREN_R);
end;
v16.parseInputValueDef = function(v126)
    local l_token_18 = v126._lexer.token;
    local v128 = v126:parseDescription();
    local v129 = v126:parseName();
    v126:expectToken(l_TokenKind_0.COLON);
    local v130 = v126:parseTypeReference();
    local v131 = nil;
    if v126:expectOptionalToken(l_TokenKind_0.EQUALS) then
        v131 = v126:parseValueLiteral(true);
    end;
    return {
        kind = l_Kind_0.INPUT_VALUE_DEFINITION,
        description = v128,
        name = v129,
        type = v130,
        defaultValue = v131,
        directives = v126:parseDirectives(true),
        loc = v126:loc(l_token_18)
    };
end;
v16.parseInterfaceTypeDefinition = function(v132)
    local l_token_19 = v132._lexer.token;
    local v134 = v132:parseDescription();
    v132:expectKeyword("interface");
    return {
        kind = l_Kind_0.INTERFACE_TYPE_DEFINITION,
        description = v134,
        name = v132:parseName(),
        interfaces = v132:parseImplementsInterfaces(),
        directives = v132:parseDirectives(true),
        fields = v132:parseFieldsDefinition(),
        loc = v132:loc(l_token_19)
    };
end;
v16.parseUnionTypeDefinition = function(v135)
    local l_token_20 = v135._lexer.token;
    local v137 = v135:parseDescription();
    v135:expectKeyword("union");
    return {
        kind = l_Kind_0.UNION_TYPE_DEFINITION,
        description = v137,
        name = v135:parseName(),
        directives = v135:parseDirectives(true),
        types = v135:parseUnionMemberTypes(),
        loc = v135:loc(l_token_20)
    };
end;
v16.parseUnionMemberTypes = function(v138)
    local v139 = {};
    if v138:expectOptionalToken(l_TokenKind_0.EQUALS) then
        v138:expectOptionalToken(l_TokenKind_0.PIPE);
        while true do
            table.insert(v139, v138:parseNamedType());
            if not v138:expectOptionalToken(l_TokenKind_0.PIPE) then
                break;
            end;
        end;
    end;
    return v139;
end;
v16.parseEnumTypeDefinition = function(v140)
    local l_token_21 = v140._lexer.token;
    local v142 = v140:parseDescription();
    v140:expectKeyword("enum");
    return {
        kind = l_Kind_0.ENUM_TYPE_DEFINITION,
        description = v142,
        name = v140:parseName(),
        directives = v140:parseDirectives(true),
        values = v140:parseEnumValuesDefinition(),
        loc = v140:loc(l_token_21)
    };
end;
v16.parseEnumValuesDefinition = function(v143)
    return v143:optionalMany(l_TokenKind_0.BRACE_L, v143.parseEnumValueDefinition, l_TokenKind_0.BRACE_R);
end;
v16.parseEnumValueDefinition = function(v144)
    return {
        kind = l_Kind_0.ENUM_VALUE_DEFINITION,
        description = v144:parseDescription(),
        name = v144:parseName(),
        directives = v144:parseDirectives(true),
        loc = v144:loc(v144._lexer.token)
    };
end;
v16.parseInputObjectTypeDefinition = function(v145)
    local l_token_22 = v145._lexer.token;
    local v147 = v145:parseDescription();
    v145:expectKeyword("input");
    return {
        kind = l_Kind_0.INPUT_OBJECT_TYPE_DEFINITION,
        description = v147,
        name = v145:parseName(),
        directives = v145:parseDirectives(true),
        fields = v145:parseInputFieldsDefinition(),
        loc = v145:loc(l_token_22)
    };
end;
v16.parseInputFieldsDefinition = function(v148)
    return v148:optionalMany(l_TokenKind_0.BRACE_L, v148.parseInputValueDef, l_TokenKind_0.BRACE_R);
end;
v16.parseTypeSystemExtension = function(v149)
    local v150 = v149._lexer:lookahead();
    if v150.kind == l_TokenKind_0.NAME then
        local l_value_3 = v150.value;
        if l_value_3 == "schema" then
            return v149:parseSchemaExtension();
        elseif l_value_3 == "scalar" then
            return v149:parseScalarTypeExtension();
        elseif l_value_3 == "type" then
            return v149:parseObjectTypeExtension();
        elseif l_value_3 == "interface" then
            return v149:parseInterfaceTypeExtension();
        elseif l_value_3 == "union" then
            return v149:parseUnionTypeExtension();
        elseif l_value_3 == "enum" then
            return v149:parseEnumTypeExtension();
        elseif l_value_3 == "input" then
            return v149:parseInputObjectTypeExtension();
        end;
    end;
    error(v149:unexpected(v150));
end;
v16.parseSchemaExtension = function(v152)
    local l_token_23 = v152._lexer.token;
    v152:expectKeyword("extend");
    v152:expectKeyword("schema");
    local v154 = v152:parseDirectives(true);
    local v155 = v152:optionalMany(l_TokenKind_0.BRACE_L, v152.parseOperationTypeDefinition, l_TokenKind_0.BRACE_R);
    if #v154 == 0 and #v155 == 0 then
        error(v152:unexpected());
    end;
    return {
        kind = l_Kind_0.SCHEMA_EXTENSION,
        directives = v154,
        operationTypes = v155,
        loc = v152:loc(l_token_23)
    };
end;
v16.parseScalarTypeExtension = function(v156)
    local l_token_24 = v156._lexer.token;
    v156:expectKeyword("extend");
    v156:expectKeyword("scalar");
    local v158 = v156:parseName();
    local v159 = v156:parseDirectives(true);
    if #v159 == 0 then
        error(v156:unexpected());
    end;
    return {
        kind = l_Kind_0.SCALAR_TYPE_EXTENSION,
        name = v158,
        directives = v159,
        loc = v156:loc(l_token_24)
    };
end;
v16.parseObjectTypeExtension = function(v160)
    local l_token_25 = v160._lexer.token;
    v160:expectKeyword("extend");
    v160:expectKeyword("type");
    local v162 = v160:parseName();
    local v163 = v160:parseImplementsInterfaces();
    local v164 = v160:parseDirectives(true);
    local v165 = v160:parseFieldsDefinition();
    if (#v163 == 0 and #v164 == 0) and #v165 == 0 then
        error(v160:unexpected());
    end;
    return {
        kind = l_Kind_0.OBJECT_TYPE_EXTENSION,
        name = v162,
        interfaces = v163,
        directives = v164,
        fields = v165,
        loc = v160:loc(l_token_25)
    };
end;
v16.parseInterfaceTypeExtension = function(v166)
    local l_token_26 = v166._lexer.token;
    v166:expectKeyword("extend");
    v166:expectKeyword("interface");
    local v168 = v166:parseName();
    local v169 = v166:parseImplementsInterfaces();
    local v170 = v166:parseDirectives(true);
    local v171 = v166:parseFieldsDefinition();
    if (#v169 == 0 and #v170 == 0) and #v171 == 0 then
        error(v166:unexpected());
    end;
    return {
        kind = l_Kind_0.INTERFACE_TYPE_EXTENSION,
        name = v168,
        interfaces = v169,
        directives = v170,
        fields = v171,
        loc = v166:loc(l_token_26)
    };
end;
v16.parseUnionTypeExtension = function(v172)
    local l_token_27 = v172._lexer.token;
    v172:expectKeyword("extend");
    v172:expectKeyword("union");
    local v174 = v172:parseName();
    local v175 = v172:parseDirectives(true);
    local v176 = v172:parseUnionMemberTypes();
    if #v175 == 0 and #v176 == 0 then
        error(v172:unexpected());
    end;
    return {
        kind = l_Kind_0.UNION_TYPE_EXTENSION,
        name = v174,
        directives = v175,
        types = v176,
        loc = v172:loc(l_token_27)
    };
end;
v16.parseEnumTypeExtension = function(v177)
    local l_token_28 = v177._lexer.token;
    v177:expectKeyword("extend");
    v177:expectKeyword("enum");
    local v179 = v177:parseName();
    local v180 = v177:parseDirectives(true);
    local v181 = v177:parseEnumValuesDefinition();
    if #v180 == 0 and #v181 == 0 then
        error(v177:unexpected());
    end;
    return {
        kind = l_Kind_0.ENUM_TYPE_EXTENSION,
        name = v179,
        directives = v180,
        values = v181,
        loc = v177:loc(l_token_28)
    };
end;
v16.parseInputObjectTypeExtension = function(v182)
    local l_token_29 = v182._lexer.token;
    v182:expectKeyword("extend");
    v182:expectKeyword("input");
    local v184 = v182:parseName();
    local v185 = v182:parseDirectives(true);
    local v186 = v182:parseInputFieldsDefinition();
    if #v185 == 0 and #v186 == 0 then
        error(v182:unexpected());
    end;
    return {
        kind = l_Kind_0.INPUT_OBJECT_TYPE_EXTENSION,
        name = v184,
        directives = v185,
        fields = v186,
        loc = v182:loc(l_token_29)
    };
end;
v16.parseDirectiveDefinition = function(v187)
    local l_token_30 = v187._lexer.token;
    local v189 = v187:parseDescription();
    v187:expectKeyword("directive");
    v187:expectToken(l_TokenKind_0.AT);
    local v190 = v187:parseName();
    local v191 = v187:parseArgumentDefs();
    local v192 = v187:expectOptionalKeyword("repeatable");
    v187:expectKeyword("on");
    return {
        kind = l_Kind_0.DIRECTIVE_DEFINITION,
        description = v189,
        name = v190,
        arguments = v191,
        repeatable = v192,
        locations = v187:parseDirectiveLocations(),
        loc = v187:loc(l_token_30)
    };
end;
v16.parseDirectiveLocations = function(v193)
    v193:expectOptionalToken(l_TokenKind_0.PIPE);
    local v194 = {};
    while true do
        table.insert(v194, v193:parseDirectiveLocation());
        if not v193:expectOptionalToken(l_TokenKind_0.PIPE) then
            break;
        end;
    end;
    return v194;
end;
v16.parseDirectiveLocation = function(v195)
    local l_token_31 = v195._lexer.token;
    local v197 = v195:parseName();
    if l_DirectiveLocation_0[v197.value] ~= nil then
        return v197;
    else
        error(v195:unexpected(l_token_31));
        return ;
    end;
end;
v16.loc = function(v198, v199)
    if (v198._options and v198._options.noLocation) ~= true then
        return l_Location_0.new(v199, v198._lexer.lastToken, v198._lexer.source);
    else
        return nil;
    end;
end;
v16.peek = function(v200, v201)
    return v200._lexer.token.kind == v201;
end;
v16.expectToken = function(v202, v203)
    local l_token_32 = v202._lexer.token;
    if l_token_32.kind == v203 then
        v202._lexer:advance();
        return l_token_32;
    else
        error(l_syntaxError_0(v202._lexer.source, l_token_32.start, "Expected " .. v15(v203) .. ", found " .. v14(l_token_32) .. "."));
        return ;
    end;
end;
v16.expectOptionalToken = function(v205, v206)
    local l_token_33 = v205._lexer.token;
    if l_token_33.kind == v206 then
        v205._lexer:advance();
        return l_token_33;
    else
        return nil;
    end;
end;
v16.expectKeyword = function(v208, v209)
    local l_token_34 = v208._lexer.token;
    if l_token_34.kind == l_TokenKind_0.NAME and l_token_34.value == v209 then
        v208._lexer:advance();
        return ;
    else
        error(l_syntaxError_0(v208._lexer.source, l_token_34.start, "Expected \"" .. v209 .. "\", found " .. v14(l_token_34) .. "."));
        return ;
    end;
end;
v16.expectOptionalKeyword = function(v211, v212)
    local l_token_35 = v211._lexer.token;
    if l_token_35.kind == l_TokenKind_0.NAME and l_token_35.value == v212 then
        v211._lexer:advance();
        return true;
    else
        return false;
    end;
end;
v16.unexpected = function(v214, v215)
    local v216 = v215 ~= nil and v215 or v214._lexer.token;
    return l_syntaxError_0(v214._lexer.source, v216.start, "Unexpected " .. v14(v216) .. ".");
end;
v16.any = function(v217, v218, v219, v220)
    v217:expectToken(v218);
    local v221 = {};
    while not v217:expectOptionalToken(v220) do
        table.insert(v221, v219(v217));
    end;
    return v221;
end;
v16.optionalMany = function(v222, v223, v224, v225)
    if not v222:expectOptionalToken(v223) then
        return {};
    else
        local v226 = {};
        while true do
            table.insert(v226, v224(v222));
            if v222:expectOptionalToken(v225) then
                break;
            end;
        end;
        return v226;
    end;
end;
v16.many = function(v227, v228, v229, v230)
    v227:expectToken(v228);
    local v231 = {};
    while true do
        table.insert(v231, v229(v227));
        if v227:expectOptionalToken(v230) then
            break;
        end;
    end;
    return v231;
end;
v16.delimitedMany = function(v232, v233, v234)
    v232:expectOptionalToken(v233);
    local v235 = {};
    while true do
        table.insert(v235, v234(v232));
        if not v232:expectOptionalToken(v233) then
            break;
        end;
    end;
    return v235;
end;
v14 = function(v236)
    local l_value_4 = v236.value;
    return v15(v236.kind) .. (l_value_4 ~= nil and " \"" .. l_value_4 .. "\"" or "");
end;
v15 = function(v238)
    return not not l_isPunctuatorTokenKind_0(v238) and "\"" .. v238 .. "\"" or v238;
end;
return {
    Parser = v16,
    parse = v19,
    parseValue = v24,
    parseType = v29
};


local l_Kind_0 = require(script.Parent.kinds).Kind;
local v1 = nil;
local v2 = nil;
local v3 = nil;
local v4 = nil;
local v5 = nil;
local v6 = nil;
local v7 = nil;
local v8 = nil;
local function v10(v9)
    return (v1(v9) or v5(v9)) or v7(v9);
end;
v1 = function(v11)
    local v12 = true;
    if v11.kind ~= l_Kind_0.OPERATION_DEFINITION then
        v12 = v11.kind == l_Kind_0.FRAGMENT_DEFINITION;
    end;
    return v12;
end;
v2 = function(v13)
    local v14 = true;
    if v13.kind ~= l_Kind_0.FIELD then
        v14 = true;
        if v13.kind ~= l_Kind_0.FRAGMENT_SPREAD then
            v14 = v13.kind == l_Kind_0.INLINE_FRAGMENT;
        end;
    end;
    return v14;
end;
v3 = function(v15)
    local v16 = true;
    if v15.kind ~= l_Kind_0.VARIABLE then
        v16 = true;
        if v15.kind ~= l_Kind_0.INT then
            v16 = true;
            if v15.kind ~= l_Kind_0.FLOAT then
                v16 = true;
                if v15.kind ~= l_Kind_0.STRING then
                    v16 = true;
                    if v15.kind ~= l_Kind_0.BOOLEAN then
                        v16 = true;
                        if v15.kind ~= l_Kind_0.NULL then
                            v16 = true;
                            if v15.kind ~= l_Kind_0.ENUM then
                                v16 = true;
                                if v15.kind ~= l_Kind_0.LIST then
                                    v16 = v15.kind == l_Kind_0.OBJECT;
                                end;
                            end;
                        end;
                    end;
                end;
            end;
        end;
    end;
    return v16;
end;
v4 = function(v17)
    local v18 = true;
    if v17.kind ~= l_Kind_0.NAMED_TYPE then
        v18 = true;
        if v17.kind ~= l_Kind_0.LIST_TYPE then
            v18 = v17.kind == l_Kind_0.NON_NULL_TYPE;
        end;
    end;
    return v18;
end;
v5 = function(v19)
    local v20 = true;
    if v19.kind ~= l_Kind_0.SCHEMA_DEFINITION then
        v20 = v6(v19) or v19.kind == l_Kind_0.DIRECTIVE_DEFINITION;
    end;
    return v20;
end;
v6 = function(v21)
    local v22 = true;
    if v21.kind ~= l_Kind_0.SCALAR_TYPE_DEFINITION then
        v22 = true;
        if v21.kind ~= l_Kind_0.OBJECT_TYPE_DEFINITION then
            v22 = true;
            if v21.kind ~= l_Kind_0.INTERFACE_TYPE_DEFINITION then
                v22 = true;
                if v21.kind ~= l_Kind_0.UNION_TYPE_DEFINITION then
                    v22 = true;
                    if v21.kind ~= l_Kind_0.ENUM_TYPE_DEFINITION then
                        v22 = v21.kind == l_Kind_0.INPUT_OBJECT_TYPE_DEFINITION;
                    end;
                end;
            end;
        end;
    end;
    return v22;
end;
v7 = function(v23)
    local v24 = true;
    if v23.kind ~= l_Kind_0.SCHEMA_EXTENSION then
        v24 = v8(v23);
    end;
    return v24;
end;
v8 = function(v25)
    local v26 = true;
    if v25.kind ~= l_Kind_0.SCALAR_TYPE_EXTENSION then
        v26 = true;
        if v25.kind ~= l_Kind_0.OBJECT_TYPE_EXTENSION then
            v26 = true;
            if v25.kind ~= l_Kind_0.INTERFACE_TYPE_EXTENSION then
                v26 = true;
                if v25.kind ~= l_Kind_0.UNION_TYPE_EXTENSION then
                    v26 = true;
                    if v25.kind ~= l_Kind_0.ENUM_TYPE_EXTENSION then
                        v26 = v25.kind == l_Kind_0.INPUT_OBJECT_TYPE_EXTENSION;
                    end;
                end;
            end;
        end;
    end;
    return v26;
end;
return {
    isDefinitionNode = v10,
    isExecutableDefinitionNode = v1,
    isSelectionNode = v2,
    isValueNode = v3,
    isTypeNode = v4,
    isTypeSystemDefinitionNode = v5,
    isTypeDefinitionNode = v6,
    isTypeSystemExtensionNode = v7,
    isTypeExtensionNode = v8
};


local l_Parent_0 = script.Parent;
local v1 = require(l_Parent_0.Parent.Parent.LuauPolyfill);
local l_Array_0 = v1.Array;
local l_String_0 = v1.String;
local l_getLocation_0 = require(l_Parent_0.location).getLocation;
local v5 = nil;
local v6 = nil;
local v7 = nil;
local v8 = nil;
local function v10(v9)
    return v7(v9.source, l_getLocation_0(v9.source, v9.start));
end;
v7 = function(v11, v12)
    local v13 = v11.locationOffset.column - 1;
    local v14 = v5(v13) .. v11.body;
    local v15 = (v12.line - 1) + 1;
    local v16 = v12.line + (v11.locationOffset.line - 1);
    local v17 = v12.column + (v12.line == 1 and v13 or 0);
    local v18 = v11.name .. ":" .. v16 .. ":" .. v17 .. "\n";
    local v19 = l_String_0.split(v14, {
        "\r\n",
        "\n",
        "\r"
    });
    local v20 = v19[v15];
    if string.len(v20) > 120 then
        local v21 = math.floor(v17 / 80) + 1;
        local v22 = v17 % 80;
        local v23 = {};
        for v24 = 1, string.len(v20), 80 do
            table.insert(v23, l_String_0.slice(v20, v24, v24 + 80));
        end;
        return v18 .. v8(l_Array_0.concat({
            {
                tostring(v16),
                v23[1]
            }
        }, l_Array_0.map(l_Array_0.slice(v23, 2, v21 + 1), function(v25)
            return {
                "",
                v25
            };
        end), {
            {
                " ",
                v5(v22 - 1) .. "^"
            }
        }, {
            {
                "",
                v23[v21 + 1]
            }
        }));
    else
        return v18 .. v8({
            {
                v16 - 1,
                v19[v15 - 1]
            },
            {
                v16,
                v20
            },
            {
                "",
                v5(v17 - 1) .. "^"
            },
            {
                v16 + 1,
                v19[v15 + 1]
            }
        });
    end;
end;
v8 = function(v26)
    local v28 = l_Array_0.filter(v26, function(v27)
        return v27[2] ~= nil;
    end);
    local v30 = math.max(table.unpack(l_Array_0.map(v28, function(v29)
        return (string.len(v29[1]));
    end)));
    return l_Array_0.join(l_Array_0.map(v28, function(v31)
        local v32 = v31[1];
        local v33 = v31[2];
        return v6(v30, v32) .. ((not not v33 and v33 ~= "") and " | " .. v33 or " |");
    end), "\n");
end;
v5 = function(v34)
    return string.rep(" ", v34);
end;
v6 = function(v35, v36)
    return v5(v35 - string.len(v36)) .. v36;
end;
return {
    printSourceLocation = v7,
    printLocation = v10
};


local l_Array_0 = require(script.Parent.Parent.Parent.LuauPolyfill).Array;
local l_HttpService_0 = game:GetService("HttpService");
local _ = require(script.Parent.ast);
local l_visit_0 = require(script.Parent.visitor).visit;
local l_printBlockString_0 = require(script.Parent.blockString).printBlockString;
local v5 = nil;
local v6 = nil;
local v7 = nil;
local v8 = nil;
local v9 = nil;
local v10 = nil;
local v11 = nil;
local v12 = nil;
local function v14(v13)
    return l_visit_0(v13, {
        leave = v5
    });
end;
v6 = function(v15)
    return function(_, v17)
        return v7({
            v17.description,
            v15(v17)
        }, "\n");
    end;
end;
v5 = {
    Name = function(_, v19)
        return v19.value;
    end,
    Variable = function(_, v21)
        return "$" .. tostring(v21.name);
    end,
    Document = function(_, v23)
        return v7(v23.definitions, "\n\n") .. "\n";
    end,
    OperationDefinition = function(_, v25)
        local l_operation_0 = v25.operation;
        local l_name_0 = v25.name;
        local v28 = v9("(", v7(v25.variableDefinitions, ", "), ")");
        local v29 = v7(v25.directives, " ");
        local l_selectionSet_0 = v25.selectionSet;
        if ((not l_name_0 and (not v29 or v29 == "")) and (not v28 or v28 == "")) and l_operation_0 == "query" then
            return l_selectionSet_0;
        else
            return v7({
                l_operation_0,
                v7({
                    l_name_0,
                    v28
                }),
                v29,
                l_selectionSet_0
            }, " ");
        end;
    end,
    VariableDefinition = function(_, v32)
        return tostring(v32.variable) .. ": " .. tostring(v32.type) .. v9(" = ", v32.defaultValue) .. v9(" ", v7(v32.directives, " "));
    end,
    SelectionSet = function(_, v34)
        return v8(v34.selections);
    end,
    Field = function(_, v36)
        local l_alias_0 = v36.alias;
        local l_name_1 = v36.name;
        local l_arguments_0 = v36.arguments;
        local l_directives_0 = v36.directives;
        local l_selectionSet_1 = v36.selectionSet;
        local v42 = v9("", l_alias_0, ": ") .. tostring(l_name_1);
        local v43 = v42 .. v9("(", v7(l_arguments_0, ", "), ")");
        local v44 = utf8.len(v43);
        assert(v44 ~= nil, "invalid utf8 string");
        if v44 > 80 then
            v43 = v42 .. v9("(\n", v10(v7(l_arguments_0, "\n")), "\n)");
        end;
        return v7({
            v43,
            v7(l_directives_0, " "),
            l_selectionSet_1
        }, " ");
    end,
    Argument = function(_, v46)
        return tostring(v46.name) .. ": " .. tostring(v46.value);
    end,
    FragmentSpread = function(_, v48)
        return "..." .. tostring(v48.name) .. v9(" ", v7(v48.directives, " "));
    end,
    InlineFragment = function(_, v50)
        return v7({
            "...",
            v9("on ", v50.typeCondition),
            v7(v50.directives, " "),
            v50.selectionSet
        }, " ");
    end,
    FragmentDefinition = function(_, v52)
        return "fragment " .. tostring(v52.name) .. v9("(", v7(v52.variableDefinitions, ", "), ")") .. " " .. "on " .. tostring(v52.typeCondition) .. " " .. v9("", v7(v52.directives, " "), " ") .. tostring(v52.selectionSet);
    end,
    IntValue = function(_, v54)
        return v54.value;
    end,
    FloatValue = function(_, v56)
        return v56.value;
    end,
    StringValue = function(_, v58, v59)
        local l_value_0 = v58.value;
        if not v58.block then
            return (l_HttpService_0:JSONEncode(l_value_0));
        else
            return (l_printBlockString_0(l_value_0, v59 == "description" and "" or "  "));
        end;
    end,
    BooleanValue = function(_, v62)
        if not v62.value then
            return "false";
        else
            return "true";
        end;
    end,
    NullValue = function(_, _)
        return "null";
    end,
    EnumValue = function(_, v66)
        return v66.value;
    end,
    ListValue = function(_, v68)
        return "[" .. v7(v68.values, ", ") .. "]";
    end,
    ObjectValue = function(_, v70)
        return "{" .. v7(v70.fields, ", ") .. "}";
    end,
    ObjectField = function(_, v72)
        return v72.name .. ": " .. v72.value;
    end,
    Directive = function(_, v74)
        return "@" .. tostring(v74.name) .. v9("(", v7(v74.arguments, ", "), ")");
    end,
    NamedType = function(_, v76)
        return v76.name;
    end,
    ListType = function(_, v78)
        return "[" .. tostring(v78.type) .. "]";
    end,
    NonNullType = function(_, v80)
        return tostring(v80.type) .. "";
    end,
    SchemaDefinition = v6(function(v81)
        return v7({
            "schema",
            v7(v81.directives, " "),
            v8(v81.operationTypes)
        }, " ");
    end),
    OperationTypeDefinition = function(_, v83)
        return tostring(v83.operation) .. ": " .. tostring(v83.type);
    end,
    ScalarTypeDefinition = v6(function(v84)
        return v7({
            "scalar",
            v84.name,
            v7(v84.directives, " ")
        }, " ");
    end),
    ObjectTypeDefinition = v6(function(v85)
        return v7({
            "type",
            v85.name,
            v9("implements ", v7(v85.interfaces, " & ")),
            v7(v85.directives, " "),
            v8(v85.fields)
        }, " ");
    end),
    FieldDefinition = v6(function(v86)
        local l_name_2 = v86.name;
        local l_arguments_1 = v86.arguments;
        return tostring(l_name_2) .. if not v12(l_arguments_1) then v9("(", v7(l_arguments_1, ", "), ")") else v9("(\n", v10(v7(l_arguments_1, "\n")), "\n)") .. ": " .. tostring(v86.type) .. v9(" ", v7(v86.directives, " "));
    end),
    InputValueDefinition = v6(function(v89)
        return v7({
            tostring(v89.name) .. ": " .. tostring(v89.type),
            v9("= ", v89.defaultValue),
            v7(v89.directives, " ")
        }, " ");
    end),
    InterfaceTypeDefinition = v6(function(v90)
        return v7({
            "interface",
            v90.name,
            v9("implements ", v7(v90.interfaces, " & ")),
            v7(v90.directives, " "),
            v8(v90.fields)
        }, " ");
    end),
    UnionTypeDefinition = v6(function(v91)
        local l_name_3 = v91.name;
        local l_directives_1 = v91.directives;
        local l_types_0 = v91.types;
        return v7({
            "union",
            l_name_3,
            v7(l_directives_1, " "),
            if not not l_types_0 and #l_types_0 ~= 0 then "= " .. v7(l_types_0, " | ") else ""
        }, " ");
    end),
    EnumTypeDefinition = v6(function(v95)
        return v7({
            "enum",
            v95.name,
            v7(v95.directives, " "),
            v8(v95.values)
        }, " ");
    end),
    EnumValueDefinition = v6(function(v96)
        return v7({
            v96.name,
            v7(v96.directives, " ")
        }, " ");
    end),
    InputObjectTypeDefinition = v6(function(v97)
        return v7({
            "input",
            v97.name,
            v7(v97.directives, " "),
            v8(v97.fields)
        }, " ");
    end),
    DirectiveDefinition = v6(function(v98)
        local l_name_4 = v98.name;
        local l_arguments_2 = v98.arguments;
        return "directive @" .. tostring(l_name_4) .. if not v12(l_arguments_2) then v9("(", v7(l_arguments_2, ", "), ")") else v9("(\n", v10(v7(l_arguments_2, "\n")), "\n)") .. (not v98.repeatable and "" or " repeatable") .. " on " .. v7(v98.locations, " | ");
    end),
    SchemaExtension = function(_, v102)
        return v7({
            "extend schema",
            v7(v102.directives, " "),
            v8(v102.operationTypes)
        }, " ");
    end,
    ScalarTypeExtension = function(_, v104)
        return v7({
            "extend scalar",
            v104.name,
            v7(v104.directives, " ")
        }, " ");
    end,
    ObjectTypeExtension = function(_, v106)
        return v7({
            "extend type",
            v106.name,
            v9("implements ", v7(v106.interfaces, " & ")),
            v7(v106.directives, " "),
            v8(v106.fields)
        }, " ");
    end,
    InterfaceTypeExtension = function(_, v108)
        return v7({
            "extend interface",
            v108.name,
            v9("implements ", v7(v108.interfaces, " & ")),
            v7(v108.directives, " "),
            v8(v108.fields)
        }, " ");
    end,
    UnionTypeExtension = function(_, v110)
        local l_name_5 = v110.name;
        local l_directives_2 = v110.directives;
        local l_types_1 = v110.types;
        return v7({
            "extend union",
            l_name_5,
            v7(l_directives_2, " "),
            if not not l_types_1 and #l_types_1 ~= 0 then "= " .. v7(l_types_1, " | ") else ""
        }, " ");
    end,
    EnumTypeExtension = function(_, v115)
        return v7({
            "extend enum",
            v115.name,
            v7(v115.directives, " "),
            v8(v115.values)
        }, " ");
    end,
    InputObjectTypeExtension = function(_, v117)
        return v7({
            "extend input",
            v117.name,
            v7(v117.directives, " "),
            v8(v117.fields)
        }, " ");
    end
};
v7 = function(v118, v119)
    v119 = v119 or "";
    if not v118 then
        return "";
    else
        return l_Array_0.join(l_Array_0.filter(v118, function(v120)
            return tostring(v120) and v120 ~= "";
        end), v119);
    end;
end;
v8 = function(v121)
    return v9("{\n", v10(v7(v121, "\n")), "\n}");
end;
v9 = function(v122, v123, v124)
    v124 = v124 or "";
    if v123 ~= nil and v123 ~= "" then
        return v122 .. tostring(v123) .. tostring(v124);
    else
        return "";
    end;
end;
v10 = function(v125)
    return v9("  ", (v125:gsub("\n", "\n  ")));
end;
v11 = function(v126)
    return string.find(tostring(v126), "\n") ~= nil;
end;
v12 = function(v127)
    local v128 = false;
    if v127 ~= nil then
        v128 = l_Array_0.some(v127, v11);
    end;
    return v128;
end;
return {
    print = v14
};


local l_Parent_0 = script.Parent.Parent;
local l_inspect_0 = require(l_Parent_0.jsutils.inspect).inspect;
local l_devAssert_0 = require(l_Parent_0.jsutils.devAssert).devAssert;
local v3 = require(l_Parent_0.jsutils.instanceOf);
local v4 = {};
v4.__index = v4;
v4.new = function(v5, v6, v7)
    local v8 = v6 or "GraphQL request";
    local v9 = v7 or {
        line = 1,
        column = 1
    };
    l_devAssert_0(typeof(v5) == "string", "Body must be a string. Received: " .. l_inspect_0(v5) .. ".");
    local v10 = {
        body = v5,
        name = v8,
        locationOffset = v9
    };
    l_devAssert_0(v10.locationOffset.line > 0, "line in locationOffset is 1-indexed and must be positive.");
    l_devAssert_0(v10.locationOffset.column > 0, "column in locationOffset is 1-indexed and must be positive.");
    return (setmetatable(v10, v4));
end;
v4.__tostring = function(_)
    return "{table Source}";
end;
isSource = function(v12)
    return v3(v12, v4);
end;
return {
    Source = v4,
    isSource = isSource
};


return {
    TokenKind = {
        SOF = "<SOF>",
        EOF = "<EOF>",
        BANG = "",
        DOLLAR = "$",
        AMP = "&",
        PAREN_L = "(",
        PAREN_R = ")",
        SPREAD = "...",
        COLON = ":",
        EQUALS = "=",
        AT = "@",
        BRACKET_L = "[",
        BRACKET_R = "]",
        BRACE_L = "{",
        PIPE = "|",
        BRACE_R = "}",
        NAME = "Name",
        INT = "Int",
        FLOAT = "Float",
        STRING = "String",
        BLOCK_STRING = "BlockString",
        COMMENT = "Comment"
    }
};


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Parent.LuauPolyfill);
local l_Array_0 = v1.Array;
local l_Object_0 = v1.Object;
local l_inspect_0 = require(l_Parent_0.jsutils.inspect).inspect;
local _ = require(l_Parent_0.language.ast);
local l_isNode_0 = require(script.Parent.ast).isNode;
local v7 = {
    Name = {},
    Document = {
        "definitions"
    },
    OperationDefinition = {
        "name",
        "variableDefinitions",
        "directives",
        "selectionSet"
    },
    VariableDefinition = {
        "variable",
        "type",
        "defaultValue",
        "directives"
    },
    Variable = {
        "name"
    },
    SelectionSet = {
        "selections"
    },
    Field = {
        "alias",
        "name",
        "arguments",
        "directives",
        "selectionSet"
    },
    Argument = {
        "name",
        "value"
    },
    FragmentSpread = {
        "name",
        "directives"
    },
    InlineFragment = {
        "typeCondition",
        "directives",
        "selectionSet"
    },
    FragmentDefinition = {
        "name",
        "variableDefinitions",
        "typeCondition",
        "directives",
        "selectionSet"
    },
    IntValue = {},
    FloatValue = {},
    StringValue = {},
    BooleanValue = {},
    NullValue = {},
    EnumValue = {},
    ListValue = {
        "values"
    },
    ObjectValue = {
        "fields"
    },
    ObjectField = {
        "name",
        "value"
    },
    Directive = {
        "name",
        "arguments"
    },
    NamedType = {
        "name"
    },
    ListType = {
        "type"
    },
    NonNullType = {
        "type"
    },
    SchemaDefinition = {
        "description",
        "directives",
        "operationTypes"
    },
    OperationTypeDefinition = {
        "type"
    },
    ScalarTypeDefinition = {
        "description",
        "name",
        "directives"
    },
    ObjectTypeDefinition = {
        "description",
        "name",
        "interfaces",
        "directives",
        "fields"
    },
    FieldDefinition = {
        "description",
        "name",
        "arguments",
        "type",
        "directives"
    },
    InputValueDefinition = {
        "description",
        "name",
        "type",
        "defaultValue",
        "directives"
    },
    InterfaceTypeDefinition = {
        "description",
        "name",
        "interfaces",
        "directives",
        "fields"
    },
    UnionTypeDefinition = {
        "description",
        "name",
        "directives",
        "types"
    },
    EnumTypeDefinition = {
        "description",
        "name",
        "directives",
        "values"
    },
    EnumValueDefinition = {
        "description",
        "name",
        "directives"
    },
    InputObjectTypeDefinition = {
        "description",
        "name",
        "directives",
        "fields"
    },
    DirectiveDefinition = {
        "description",
        "name",
        "arguments",
        "locations"
    },
    SchemaExtension = {
        "directives",
        "operationTypes"
    },
    ScalarTypeExtension = {
        "name",
        "directives"
    },
    ObjectTypeExtension = {
        "name",
        "interfaces",
        "directives",
        "fields"
    },
    InterfaceTypeExtension = {
        "name",
        "interfaces",
        "directives",
        "fields"
    },
    UnionTypeExtension = {
        "name",
        "directives",
        "types"
    },
    EnumTypeExtension = {
        "name",
        "directives",
        "values"
    },
    InputObjectTypeExtension = {
        "name",
        "directives",
        "fields"
    }
};
local v8 = l_Object_0.freeze({});
local v9 = require(l_Parent_0.luaUtils.null);
local v10 = nil;
local v11 = nil;
local function v35(v12, v13, v14)
    local v15 = v14 or v7;
    local v16 = nil;
    local v17 = l_Array_0.isArray(v12);
    local v18 = {
        v12
    };
    local v19 = 0;
    local v20 = {};
    local v21 = nil;
    local v22 = nil;
    local v23 = nil;
    local v24 = {};
    local v25 = {};
    local l_v12_0 = v12;
    while true do
        v19 = v19 + 1;
        local v27 = v19 == #v18 + 1;
        local v28 = v27 and #v20 ~= 0;
        local v29;
        if not v27 then
            v22 = if not v23 then nil else if v17 then v19 else v18[v19];
            v21 = if not v23 then l_v12_0 else v23[v22];
            if v21 ~= nil and v21 ~= v9 then
                if v23 then
                    table.insert(v24, v22);
                end;
            else
                goto label0;
            end;
        else
            v22 = if #v25 == 0 then nil else v24[#v24];
            v21 = v23;
            v23 = table.remove(v25);
            if v28 then
                if not v17 then
                    v29 = {};
                    for v30 in pairs(v21) do
                        v29[v30] = v21[v30];
                    end;
                    v21 = v29;
                else
                    v21 = l_Array_0.slice(v21);
                end;
                v29 = 0;
                for v31 = 1, #v20 do
                    local v32 = v20[v31][1];
                    local v33 = v20[v31][2];
                    if v17 then
                        v32 = v32 - v29;
                    end;
                    if v17 and v33 == nil then
                        l_Array_0.splice(v21, v32, 1);
                        v29 = v29 + 1;
                    else
                        v21[v32] = v33;
                    end;
                end;
            end;
            v19 = v16.index;
            v18 = v16.keys;
            v20 = v16.edits;
            v17 = v16.inArray;
            v16 = v16.prev;
        end;
        v29 = nil;
        if not l_Array_0.isArray(v21) then
            if not l_isNode_0(v21) then
                error("Invalid AST Node: " .. l_inspect_0(v21) .. ".");
            end;
            local v34 = v11(v13, v21.kind, v27);
            if v34 then
                v29 = v34(v13, v21, v22, v23, v24, v25);
                if v29 ~= v8 then
                    if v29 == false then
                        if not v27 then
                            table.remove(v24);
                            goto label0 --[[  true, true  ]];
                        end;
                    elseif not (v29 == nil) or v29 == v9 then
                        if v29 == v9 then
                            v29 = nil;
                        end;
                        table.insert(v20, {
                            v22,
                            v29
                        });
                        if not v27 then
                            if not l_isNode_0(v29) then
                                table.remove(v24);
                                goto label0 --[[  true, true  ]];
                            else
                                v21 = v29;
                            end;
                        end;
                    end;
                else
                    break;
                end;
            end;
        end;
        if not (not (v29 == nil) or not v28) then
            table.insert(v20, {
                v22,
                v21
            });
        end;
        if not v27 then
            v16 = {
                inArray = v17,
                index = v19,
                keys = v18,
                edits = v20,
                prev = v16
            };
            v17 = l_Array_0.isArray(v21);
            v18 = if not v17 then v15[v21.kind] or {} else v21;
            v19 = 0;
            v20 = {};
            if v23 then
                table.insert(v25, v23);
            end;
            v23 = v21;
        else
            table.remove(v24);
        end;
        ::label0::;
        if not (v16 ~= nil) then
            break;
        end;
    end;
    if #v20 ~= 0 then
        l_v12_0 = v20[#v20][2];
    end;
    return l_v12_0;
end;
v10 = function(v36)
    local v37 = {};
    return {
        enter = function(_, v39, ...)
            for v40 = 1, #v36 do
                if v37[v40] == nil then
                    local v41 = v11(v36[v40], v39.kind, false);
                    if v41 then
                        local v42 = v41(v36[v40], v39, ...);
                        if v42 == false then
                            v37[v40] = v39;
                        elseif v42 == v8 then
                            v37[v40] = v8;
                        elseif v42 ~= nil then
                            return v42;
                        end;
                    end;
                end;
            end;
        end,
        leave = function(_, ...)
            local v44 = ...;
            for v45 = 1, #v36 do
                if v37[v45] == nil then
                    local v46 = v11(v36[v45], v44.kind, true);
                    if v46 then
                        local v47 = v46(v36[v45], ...);
                        if v47 == v8 then
                            v37[v45] = v8;
                        elseif v47 ~= nil and v47 ~= false then
                            return v47;
                        end;
                    end;
                elseif v37[v45] == v44 then
                    v37[v45] = nil;
                end;
            end;
        end
    };
end;
v11 = function(v48, v49, v50)
    local v51 = v48[v49];
    if not v51 then
        local v52 = nil;
        v52 = if not v50 then v48.enter else v48.leave;
        if v52 then
            if type(v52) == "function" then
                return v52;
            else
                local v53 = v52[v49];
                if type(v53) == "function" then
                    return v53;
                end;
            end;
        end;
    elseif not v50 and type(v51) == "function" then
        return v51;
    else
        local v54 = nil;
        if typeof(v51) ~= "function" then
            v54 = if not v50 then v51.enter else v51.leave;
        end;
        if type(v54) == "function" then
            return v54;
        end;
    end;
end;
return {
    BREAK = v8,
    REMOVE = v9,
    visit = v35,
    visitInParallel = v10,
    getVisitFn = v11,
    QueryDocumentKeys = v7
};


local v0 = require(script.Parent.deepEqual);
local v1 = require(script.Parent.deepContains);
return function(v2, v3, v4)
    for _, v6 in ipairs(v2) do
        if not v4 then
            if v0(v6, v3) then
                return true;
            end;
        elseif v1(v6, v3) then
            return true;
        end;
    end;
    return false;
end;


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local _ = require(l_Parent_1.LuauPolyfill);
local v3 = require(l_Parent_1.Promise);
local _ = require(l_Parent_0.jsutils.PromiseOrValue);
return {
    coerceToPromise = function(v5)
        if not v3.is(v5) then
            return (v3.resolve(v5));
        else
            return v5;
        end;
    end
};


local l_Number_0 = require(script.Parent.Parent.Parent.LuauPolyfill).Number;
local v1 = require(script.Parent.null);
local function v2(v3, v4)
    if typeof(v3) ~= typeof(v4) then
        return false, (("{1}: value of type '%s'\n{2}: value of type '%s'"):format(typeof(v3), (typeof(v4))));
    elseif not l_Number_0.isNaN(v3) or not l_Number_0.isNaN(v4) then
        if v3 == v4 then
            return true;
        elseif not (v3 ~= v1 and v4 ~= v1) or typeof(v3) ~= "table" then
            return false, string.format("{1} (%s) ~= {2} (%s)", tostring(v3), (tostring(v4)));
        else
            for v5, v6 in pairs(v4) do
                local v7, v8 = v2(v3[v5], v6);
                if not v7 then
                    return false, (v8:gsub("{1}", ("{1}[%s]"):format((tostring(v5)))):gsub("{2}", ("{2}[%s]"):format((tostring(v5)))));
                end;
            end;
            return true;
        end;
    else
        return true;
    end;
end;
return v2;


local l_Number_0 = require(script.Parent.Parent.Parent.LuauPolyfill).Number;
local v1 = require(script.Parent.null);
local function v2(v3, v4)
    if typeof(v3) ~= typeof(v4) then
        return false, (("{1}: value of type '%s'\n{2}: value of type '%s'"):format(typeof(v3), (typeof(v4))));
    elseif not l_Number_0.isNaN(v3) or not l_Number_0.isNaN(v4) then
        if v3 == v4 then
            return true;
        elseif not (v3 ~= v1 and v4 ~= v1) or typeof(v3) ~= "table" then
            return false, string.format("{1} (%s) ~= {2} (%s)", tostring(v3), (tostring(v4)));
        else
            local v5 = {};
            for v6, v7 in pairs(v3) do
                v5[v6] = true;
                local v8, v9 = v2(v7, v4[v6]);
                if not v8 then
                    return false, (v9:gsub("{1}", ("{1}[%s]"):format((tostring(v6)))):gsub("{2}", ("{2}[%s]"):format((tostring(v6)))));
                end;
            end;
            for v10, v11 in pairs(v4) do
                if not v5[v10] then
                    local v12, v13 = v2(v3[v10], v11);
                    if not v12 then
                        return false, (v13:gsub("{1}", ("{1}[%s]"):format((tostring(v10)))):gsub("{2}", ("{2}[%s]"):format((tostring(v10)))));
                    end;
                end;
            end;
            return true;
        end;
    else
        return true;
    end;
end;
return v2;


local v0 = require(script.Parent.null);
return {
    isNillish = function(v1)
        local v2 = true;
        if v1 ~= nil then
            v2 = v1 == v0;
        end;
        return v2;
    end,
    isNotNillish = function(v3)
        local v4 = false;
        if v3 ~= nil then
            v4 = v3 ~= v0;
        end;
        return v4;
    end
};


local v0 = {};
local function v4(v1)
    if type(v1) ~= "table" then
        return (type(v1));
    else
        local v2 = 1;
        for _ in pairs(v1) do
            if v1[v2] ~= nil then
                v2 = v2 + 1;
            else
                return "table";
            end;
        end;
        if v2 == 1 then
            return "table";
        else
            return "array";
        end;
    end;
end;
local function v10(v5)
    local v6 = {
        "\\",
        "\"",
        "/",
        "\b",
        "\f",
        "\n",
        "\r",
        "\t"
    };
    local v7 = {
        "\\",
        "\"",
        "/",
        "b",
        "f",
        "n",
        "r",
        "t"
    };
    for v8, v9 in ipairs(v6) do
        v5 = v5:gsub(v9, "\\" .. v7[v8]);
    end;
    return v5;
end;
v0.stringify = function(v11, v12)
    local v13 = {};
    local v14 = v4(v11);
    if v14 == "array" then
        if v12 then
            error("Can't encode array as key.");
        end;
        v13[#v13 + 1] = "[";
        for v15, v16 in ipairs(v11) do
            if v15 > 1 then
                v13[#v13 + 1] = ", ";
            end;
            v13[#v13 + 1] = v0.stringify(v16);
        end;
        v13[#v13 + 1] = "]";
    elseif v14 == "table" then
        if v12 then
            error("Can't encode table as key.");
        end;
        v13[#v13 + 1] = "{";
        for v17, v18 in pairs(v11) do
            if #v13 > 1 then
                v13[#v13 + 1] = ", ";
            end;
            v13[#v13 + 1] = v0.stringify(v17, true);
            v13[#v13 + 1] = ":";
            v13[#v13 + 1] = v0.stringify(v18);
        end;
        v13[#v13 + 1] = "}";
    elseif v14 == "string" then
        return "\"" .. v10(v11) .. "\"";
    elseif v14 == "number" then
        if not v12 then
            return (tostring(v11));
        else
            return "\"" .. tostring(v11) .. "\"";
        end;
    elseif v14 == "boolean" then
        return (tostring(v11));
    elseif v14 == "nil" then
        return "null";
    else
        error("Unjsonifiable type: " .. v14 .. ".");
    end;
    return table.concat(v13);
end;
return v0;


local l_Map_0 = require(script.Parent.Parent.Parent.LuauPolyfill).Map;
return {
    keyMapOrdered = function(v1, v2)
        local v3 = l_Map_0.new();
        for v4 = 1, #v1 do
            local v5 = v1[v4];
            v3:set(v2(v5), v5);
        end;
        return v3;
    end
};


local l_Map_0 = require(script.Parent.Parent.Parent.LuauPolyfill).Map;
return {
    mapValueOrdered = function(v1, v2)
        local v3 = l_Map_0.new();
        for _, v5 in v1, nil, nil do
            local v6 = v5[1];
            v3:set(v6, v2(v5[2], v6));
        end;
        return v3;
    end
};


return (setmetatable({
    __NULL_IDENTIFIER__ = "__GRAPHQL_NULL_OBJECT__"
}, {
    __newindex = function(_, v1, _)
        error(("%q (%s) is not a valid member of %s"):format(tostring(v1), typeof(v1), "null"), 2);
    end,
    __metatable = false,
    __tostring = function()
        return "null";
    end
}));


local l_HttpService_0 = game:GetService("HttpService");
local v1 = l_HttpService_0:JSONEncode((require(script.Parent.null)));
return function(v2)
    return (l_HttpService_0:JSONEncode(v2):gsub(v1, "null"));
end;


local l_String_0 = require(script.Parent.Parent.Parent.LuauPolyfill).String;
return function(v1)
    return "\"\\u" .. l_String_0.slice("0000" .. string.format("%x", v1), -4):upper() .. "\"";
end;


return {
    objectEntries = require(script.Parent.Parent.Parent.LuauPolyfill).Object.entries
};


return {
    objectValues = require(script.Parent.Parent.Parent.LuauPolyfill).Object.values
};


local v0 = require(script.subscribe);
return {
    subscribe = v0.subscribe,
    createSourceEventStream = v0.createSourceEventStream
};


local l_Parent_0 = script.Parent.Parent;
local _ = require(l_Parent_0.Parent.LuauPolyfill);
local _ = require(l_Parent_0.language.ast);
local _ = require(l_Parent_0.execution.execute);
local _ = require(l_Parent_0.type.schema);
local _ = require(l_Parent_0.type.definition);
return {
    subscribe = function(_)
        error("graphql-lua does not currently implement subscriptions");
    end,
    createSourceEventStream = function(_, _, _, _, _, _, _)
        error("graphql-lua does not currently implement subscriptions");
    end
};


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Parent.LuauPolyfill);
local l_Array_0 = v1.Array;
local l_Error_0 = v1.Error;
local l_Map_0 = v1.Map;
local l_Object_0 = v1.Object;
local l_coerceToMap_0 = v1.coerceToMap;
local v7 = require(l_Parent_0.luaUtils.null);
local v8 = l_Object_0.freeze({});
local l_isNillish_0 = require(l_Parent_0.luaUtils.isNillish).isNillish;
local l_jsutils_0 = l_Parent_0.jsutils;
local _ = require(l_jsutils_0.ObjMap);
local l_inspect_0 = require(l_jsutils_0.inspect).inspect;
local l_keyMap_0 = require(l_jsutils_0.keyMap).keyMap;
local l_toObjMap_0 = require(l_jsutils_0.toObjMap).toObjMap;
local l_keyValMap_0 = require(l_jsutils_0.keyValMap).keyValMap;
local l_devAssert_0 = require(l_jsutils_0.devAssert).devAssert;
local v17 = require(l_jsutils_0.instanceOf);
local l_didYouMean_0 = require(l_jsutils_0.didYouMean).didYouMean;
local l_isObjectLike_0 = require(l_jsutils_0.isObjectLike).isObjectLike;
local l_identityFunc_0 = require(l_jsutils_0.identityFunc).identityFunc;
local l_suggestionList_0 = require(l_jsutils_0.suggestionList).suggestionList;
local _ = require(l_jsutils_0.PromiseOrValue);
local _ = require(l_jsutils_0.Path);
local l_mapValueOrdered_0 = require(l_Parent_0.luaUtils.mapValueOrdered).mapValueOrdered;
local l_GraphQLError_0 = require(l_Parent_0.error.GraphQLError).GraphQLError;
local l_language_0 = l_Parent_0.language;
local l_Kind_0 = require(l_language_0.kinds).Kind;
local l_print_0 = require(l_language_0.printer).print;
local _ = require(l_Parent_0.language.ast);
local l_valueFromASTUntyped_0 = require(l_Parent_0.utilities.valueFromASTUntyped).valueFromASTUntyped;
local v31 = nil;
local v32 = nil;
local v33 = nil;
local v34 = nil;
local v35 = nil;
local v36 = nil;
local v37 = nil;
local v38 = nil;
local v39 = nil;
local v40 = nil;
local v41 = nil;
local v42 = nil;
local v43 = nil;
local v44 = nil;
local v45 = nil;
local v46 = nil;
local v47 = nil;
local v48 = nil;
local v49 = nil;
local v50 = nil;
local v51 = nil;
local v52 = nil;
local v53 = nil;
local v54 = nil;
local v55 = nil;
local v56 = nil;
local v57 = nil;
local v58 = nil;
local v59 = nil;
local v60 = nil;
local v61 = nil;
local v62 = nil;
local v63 = nil;
local v64 = nil;
local v65 = nil;
local v66 = nil;
local v67 = nil;
local v68 = nil;
local v69 = nil;
local v70 = nil;
local v71 = nil;
local v72 = nil;
local v73 = nil;
local v74 = nil;
local v75 = nil;
local v76 = nil;
local v77 = nil;
local v78 = nil;
local v79 = nil;
local v80 = {};
local v81 = {};
local v82 = {};
local v83 = {};
local v84 = {};
local v85 = {};
v31 = function(v86)
    return ((((((v33(v86) or v35(v86)) or v37(v86)) or v39(v86)) or v41(v86)) or v43(v86)) or v45(v86)) or v47(v86);
end;
v32 = function(v87)
    if not v31(v87) then
        error(l_Error_0.new(("Expected %s to be a GraphQL type."):format(l_inspect_0(v87))));
    end;
    return v87;
end;
v33 = function(v88)
    return v17(v88, v80);
end;
v34 = function(v89)
    if not v33(v89) then
        error(l_Error_0.new(("Expected %s to be a GraphQL Scalar type."):format(l_inspect_0(v89))));
    end;
    return v89;
end;
v35 = function(v90)
    return v17(v90, v81);
end;
v36 = function(v91)
    if not v35(v91) then
        error(l_Error_0.new(("Expected %s to be a GraphQL Object type."):format(l_inspect_0(v91))));
    end;
    return v91;
end;
v37 = function(v92)
    return v17(v92, v82);
end;
v38 = function(v93)
    if not v37(v93) then
        error(l_Error_0.new(("Expected %s to be a GraphQL Interface type."):format(l_inspect_0(v93))));
    end;
    return v93;
end;
v39 = function(v94)
    return v17(v94, v83);
end;
v40 = function(v95)
    if not v39(v95) then
        error(l_Error_0.new(("Expected %s to be a GraphQL Union type."):format(l_inspect_0(v95))));
    end;
    return v95;
end;
v41 = function(v96)
    return v17(v96, v84);
end;
v42 = function(v97)
    if not v41(v97) then
        error(l_Error_0.new(("Expected %s to be a GraphQL Enum type."):format(l_inspect_0(v97))));
    end;
    return v97;
end;
v43 = function(v98)
    return v17(v98, v85);
end;
v44 = function(v99)
    if not v43(v99) then
        error(l_Error_0.new(("Expected %s to be a GraphQL Input Object type."):format(l_inspect_0(v99))));
    end;
    return v99;
end;
v45 = function(v100)
    return v17(v100, v78);
end;
v46 = function(v101)
    if not v45(v101) then
        error(l_Error_0.new(("Expected %s to be a GraphQL List type."):format(l_inspect_0(v101))));
    end;
    return v101;
end;
v47 = function(v102)
    return v17(v102, v79);
end;
v48 = function(v103)
    if not v47(v103) then
        error(l_Error_0.new(("Expected %s to be a GraphQL Non-Null type."):format(l_inspect_0(v103))));
    end;
    return v103;
end;
v49 = function(v104)
    return ((v33(v104) or v41(v104)) or v43(v104)) or v59(v104) and v49(v104.ofType);
end;
v50 = function(v105)
    if not v49(v105) then
        error(l_Error_0.new(("Expected %s to be a GraphQL input type."):format(l_inspect_0(v105))));
    end;
    return v105;
end;
v51 = function(v106)
    return ((((v33(v106) or v35(v106)) or v37(v106)) or v39(v106)) or v41(v106)) or v59(v106) and v51(v106.ofType);
end;
v52 = function(v107)
    if not v51(v107) then
        error(l_Error_0.new(("Expected %s to be a GraphQL output type."):format(l_inspect_0(v107))));
    end;
    return v107;
end;
v53 = function(v108)
    return v33(v108) or v41(v108);
end;
v54 = function(v109)
    if not v53(v109) then
        error(l_Error_0.new(("Expected %s to be a GraphQL leaf type."):format(l_inspect_0(v109))));
    end;
    return v109;
end;
v55 = function(v110)
    return (v35(v110) or v37(v110)) or v39(v110);
end;
v56 = function(v111)
    if not v55(v111) then
        error(l_Error_0.new(("Expected %s to be a GraphQL composite type."):format(l_inspect_0(v111))));
    end;
    return v111;
end;
v57 = function(v112)
    return v37(v112) or v39(v112);
end;
v58 = function(v113)
    if not v57(v113) then
        error(l_Error_0.new(("Expected %s to be a GraphQL abstract type."):format(l_inspect_0(v113))));
    end;
    return v113;
end;
v78 = {};
v78.__index = v78;
v78.new = function(v114)
    local v115 = {};
    l_devAssert_0(v31(v114), ("Expected %s to be a GraphQL type."):format(l_inspect_0(v114)));
    v115.ofType = v114;
    return (setmetatable(v115, v78));
end;
v78.__tostring = function(v116)
    return v116:toString();
end;
v78.toString = function(v117)
    return "[" .. tostring(v117.ofType) .. "]";
end;
v78.toJSON = function(v118)
    return v118:toString();
end;
v79 = {};
v79.__index = v79;
v79.new = function(v119)
    local v120 = {};
    l_devAssert_0(v61(v119), ("Expected %s to be a GraphQL nullable type."):format(l_inspect_0(v119)));
    v120.ofType = v119;
    return (setmetatable(v120, v79));
end;
v79.__tostring = function(v121)
    return v121:toString();
end;
v79.toString = function(v122)
    return tostring(v122.ofType) .. "";
end;
v79.toJSON = function(v123)
    return v123:toString();
end;
v59 = function(v124)
    return v45(v124) or v47(v124);
end;
v60 = function(v125)
    if not v59(v125) then
        error(l_Error_0.new(("Expected %s to be a GraphQL wrapping type."):format(l_inspect_0(v125))));
    end;
    return v125;
end;
v61 = function(v126)
    return v31(v126) and not v47(v126);
end;
v62 = function(v127)
    if not v61(v127) then
        error(l_Error_0.new(("Expected %s to be a GraphQL nullable type."):format(l_inspect_0(v127))));
    end;
    return v127;
end;
v63 = function(v128)
    if not v128 then
        return nil;
    elseif not v47(v128) then
        return v128;
    else
        return v128.ofType;
    end;
end;
v64 = function(v129)
    return ((((v33(v129) or v35(v129)) or v37(v129)) or v39(v129)) or v41(v129)) or v43(v129);
end;
v65 = function(v130)
    if not v64(v130) then
        error(l_Error_0.new(("Expected %s to be a GraphQL named type."):format(l_inspect_0(v130))));
    end;
    return v130;
end;
v66 = function(v131)
    if not v131 then
        return nil;
    else
        local l_v131_0 = v131;
        while v59(l_v131_0) do
            l_v131_0 = l_v131_0.ofType;
        end;
        return l_v131_0;
    end;
end;
local function _(v133)
    if typeof(v133) == "function" then
        return (v133());
    else
        return v133;
    end;
end;
local function _(v135)
    if v135 and #v135 > 0 then
        return v135;
    else
        return nil;
    end;
end;
v80.__index = v80;
v80.new = function(v137)
    local v138 = {};
    local v139 = if not v137.parseValue then l_identityFunc_0 else v137.parseValue;
    v138.name = v137.name;
    v138.description = v137.description;
    v138.specifiedByUrl = v137.specifiedByUrl;
    local v140 = if not v137.serialize then l_identityFunc_0 else v137.serialize;
    v138.serialize = function(_, ...)
        return v140(...);
    end;
    v138.parseValue = function(_, ...)
        return v139(...);
    end;
    local v145 = not v137.parseLiteral and function(v143, v144)
        return v139(l_valueFromASTUntyped_0(v143, v144));
    end or v137.parseLiteral;
    v138.parseLiteral = function(_, ...)
        return v145(...);
    end;
    v138.extensions = if not v137.extensions then nil else l_toObjMap_0(v137.extensions);
    v138.astNode = v137.astNode;
    local l_extensionASTNodes_0 = v137.extensionASTNodes;
    v138.extensionASTNodes = if not not l_extensionASTNodes_0 and #l_extensionASTNodes_0 > 0 then l_extensionASTNodes_0 else nil;
    l_devAssert_0(typeof(v137.name) == "string", "Must provide name.");
    l_devAssert_0(l_isNillish_0(v137.specifiedByUrl) or typeof(v137.specifiedByUrl) == "string", ("%s must provide \"specifiedByUrl\" as a string, "):format(v138.name) .. ("but got: %s."):format(l_inspect_0(v137.specifiedByUrl)));
    local l_l_devAssert_0_0 = l_devAssert_0;
    l_extensionASTNodes_0 = true;
    if v137.serialize ~= nil then
        l_extensionASTNodes_0 = typeof(v137.serialize) == "function";
    end;
    l_l_devAssert_0_0(l_extensionASTNodes_0, ("%s must provide \"serialize\" function. If this custom Scalar is also used as an input type, ensure \"parseValue\" and \"parseLiteral\" functions are also provided."):format(v138.name));
    if v137.parseLiteral then
        l_l_devAssert_0_0 = l_devAssert_0;
        l_extensionASTNodes_0 = false;
        if typeof(v137.parseValue) == "function" then
            l_extensionASTNodes_0 = typeof(v137.parseLiteral) == "function";
        end;
        l_l_devAssert_0_0(l_extensionASTNodes_0, ("%s must provide both \"parseValue\" and \"parseLiteral\" functions."):format(v138.name));
    end;
    return (setmetatable(v138, v80));
end;
v80.toConfig = function(v149)
    return {
        name = v149.name,
        description = v149.description,
        specifiedByUrl = v149.specifiedByUrl,
        serialize = v149.serialize,
        parseValue = v149.parseValue,
        parseLiteral = v149.parseLiteral,
        extensions = v149.extensions,
        astNode = v149.astNode,
        extensionASTNodes = if not v149.extensionASTNodes then {} else v149.extensionASTNodes
    };
end;
v80.__tostring = function(v150)
    return v150:toString();
end;
v80.toString = function(v151)
    return v151.name;
end;
v80.toJSON = function(v152)
    return v152:toString();
end;
v81.__index = v81;
v81.new = function(v153)
    local v154 = {
        name = v153.name,
        description = v153.description,
        isTypeOf = v153.isTypeOf,
        extensions = if not v153.extensions then nil else l_toObjMap_0(v153.extensions),
        astNode = v153.astNode
    };
    local l_extensionASTNodes_1 = v153.extensionASTNodes;
    v154.extensionASTNodes = if not not l_extensionASTNodes_1 and #l_extensionASTNodes_1 > 0 then l_extensionASTNodes_1 else nil;
    v154._fields = function()
        return v77(v153);
    end;
    v154._interfaces = function()
        return v76(v153);
    end;
    l_devAssert_0(typeof(v153.name) == "string", "Must provide name.");
    local l_l_devAssert_0_1 = l_devAssert_0;
    l_extensionASTNodes_1 = true;
    if v153.isTypeOf ~= nil then
        l_extensionASTNodes_1 = typeof(v153.isTypeOf) == "function";
    end;
    l_l_devAssert_0_1(l_extensionASTNodes_1, ("%s must provide \"isTypeOf\" as a function, " .. "but got: %s."):format(v154.name, l_inspect_0(v153.isTypeOf)));
    return (setmetatable(v154, v81));
end;
v81.getFields = function(v157)
    if typeof(v157._fields) == "function" then
        v157._fields = v157._fields();
    end;
    return v157._fields;
end;
v81.getInterfaces = function(v158)
    if typeof(v158._interfaces) == "function" then
        v158._interfaces = v158._interfaces();
    end;
    return v158._interfaces;
end;
v81.toConfig = function(v159)
    return {
        name = v159.name,
        description = v159.description,
        interfaces = v159:getInterfaces(),
        fields = v75(v159:getFields()),
        isTypeOf = v159.isTypeOf,
        extensions = v159.extensions,
        astNode = v159.astNode,
        extensionASTNodes = v159.extensionASTNodes or {}
    };
end;
v81.__tostring = function(v160)
    return v160:toString();
end;
v81.toString = function(v161)
    return v161.name;
end;
v81.toJSON = function(v162)
    return v162:toString();
end;
v76 = function(v163)
    local l_interfaces_0 = v163.interfaces;
    l_interfaces_0 = if typeof(l_interfaces_0) == "function" then l_interfaces_0() else l_interfaces_0 or {};
    l_devAssert_0(l_Array_0.isArray(l_interfaces_0), ("%s interfaces must be an Array or a function which returns an Array."):format(v163.name));
    return l_interfaces_0;
end;
v77 = function(v165)
    local l_fields_0 = v165.fields;
    local v167 = if typeof(l_fields_0) == "function" then l_fields_0() else l_fields_0;
    l_devAssert_0(v72(v167) or v17(v167, l_Map_0), ("%s fields must be an object with field names as keys or a function which returns such an object."):format(v165.name));
    return l_mapValueOrdered_0(l_coerceToMap_0(v167), function(v168, v169)
        l_devAssert_0(v72(v168), ("%s.%s field config must be an object."):format(v165.name, v169));
        local l_l_devAssert_0_2 = l_devAssert_0;
        local v171 = true;
        if v168.resolve ~= nil then
            v171 = typeof(v168.resolve) == "function";
        end;
        l_l_devAssert_0_2(v171, ("%s.%s field resolver must be a function if "):format(v165.name, v169) .. ("provided, but got: %s."):format(l_inspect_0(v168.resolve)));
        l_l_devAssert_0_2 = if not v168.args then {} else v168.args;
        l_devAssert_0(v72(l_l_devAssert_0_2) or v17(l_l_devAssert_0_2, l_Map_0), ("%s.%s args must be an object with argument names as keys."):format(v165.name, v169));
        return {
            name = v169,
            description = v168.description,
            type = v168.type,
            args = l_Array_0.map(l_coerceToMap_0(l_l_devAssert_0_2):entries(), function(v172)
                local v173 = v172[1];
                local v174 = v172[2];
                return {
                    name = v173,
                    description = v174.description,
                    type = v174.type,
                    defaultValue = v174.defaultValue,
                    deprecationReason = v174.deprecationReason,
                    extensions = if not v174.extensions then nil else l_toObjMap_0(v174.extensions),
                    astNode = v174.astNode
                };
            end),
            resolve = v168.resolve,
            subscribe = v168.subscribe,
            deprecationReason = v168.deprecationReason,
            extensions = if not v168.extensions then nil else l_toObjMap_0(v168.extensions),
            astNode = v168.astNode
        };
    end);
end;
v72 = function(v175)
    local v176 = false;
    if v175 ~= v7 then
        v176 = l_isObjectLike_0(v175) and (not l_Array_0.isArray(v175) or next(v175) == nil);
    end;
    return v176;
end;
v75 = function(v177)
    return l_mapValueOrdered_0(v177, function(v178)
        return {
            description = v178.description,
            type = v178.type,
            args = v67(v178.args),
            resolve = v178.resolve,
            subscribe = v178.subscribe,
            deprecationReason = v178.deprecationReason,
            extensions = v178.extensions,
            astNode = v178.astNode
        };
    end);
end;
v67 = function(v179)
    return l_keyValMap_0(v179, function(v180)
        return v180.name;
    end, function(v181)
        return {
            description = v181.description,
            type = v181.type,
            defaultValue = v181.defaultValue,
            deprecationReason = v181.deprecationReason,
            extensions = v181.extensions,
            astNode = v181.astNode
        };
    end);
end;
v68 = function(v182)
    return v47(v182.type) and v182.defaultValue == nil;
end;
v82.__index = v82;
v82.new = function(v183)
    local v184 = {
        name = v183.name,
        description = v183.description,
        resolveType = v183.resolveType,
        extensions = if not v183.extensions then nil else l_toObjMap_0(v183.extensions),
        astNode = v183.astNode
    };
    local l_extensionASTNodes_2 = v183.extensionASTNodes;
    v184.extensionASTNodes = if not not l_extensionASTNodes_2 and #l_extensionASTNodes_2 > 0 then l_extensionASTNodes_2 else nil;
    v184._fields = function()
        return v77(v183);
    end;
    v184._interfaces = function()
        return v76(v183);
    end;
    l_devAssert_0(typeof(v183.name) == "string", "Must provide name.");
    local l_l_devAssert_0_3 = l_devAssert_0;
    l_extensionASTNodes_2 = true;
    if v183.resolveType ~= nil then
        l_extensionASTNodes_2 = typeof(v183.resolveType) == "function";
    end;
    l_l_devAssert_0_3(l_extensionASTNodes_2, ("%s must provide \"resolveType\" as a function, " .. "but got: %s."):format(v184.name, l_inspect_0(v183.resolveType)));
    return (setmetatable(v184, v82));
end;
v82.getFields = function(v187)
    if typeof(v187._fields) == "function" then
        v187._fields = v187._fields();
    end;
    return v187._fields;
end;
v82.getInterfaces = function(v188)
    if typeof(v188._interfaces) == "function" then
        v188._interfaces = v188._interfaces();
    end;
    return v188._interfaces;
end;
v82.toConfig = function(v189)
    return {
        name = v189.name,
        description = v189.description,
        interfaces = v189:getInterfaces(),
        fields = v75(v189:getFields()),
        resolveType = v189.resolveType,
        extensions = v189.extensions,
        astNode = v189.astNode,
        extensionASTNodes = v189.extensionASTNodes or {}
    };
end;
v82.__tostring = function(v190)
    return v190:toString();
end;
v82.toString = function(v191)
    return v191.name;
end;
v82.toJSON = function(v192)
    return v192:toString();
end;
v83.__index = v83;
v83.new = function(v193)
    local v194 = {
        name = v193.name,
        description = v193.description,
        resolveType = v193.resolveType,
        extensions = if not v193.extensions then nil else l_toObjMap_0(v193.extensions),
        astNode = v193.astNode
    };
    local l_extensionASTNodes_3 = v193.extensionASTNodes;
    v194.extensionASTNodes = if not not l_extensionASTNodes_3 and #l_extensionASTNodes_3 > 0 then l_extensionASTNodes_3 else nil;
    v194._types = function()
        return v71(v193);
    end;
    l_devAssert_0(typeof(v193.name) == "string", "Must provide name.");
    local l_l_devAssert_0_4 = l_devAssert_0;
    l_extensionASTNodes_3 = true;
    if v193.resolveType ~= nil then
        l_extensionASTNodes_3 = typeof(v193.resolveType) == "function";
    end;
    l_l_devAssert_0_4(l_extensionASTNodes_3, ("%s must provide \"resolveType\" as a function, " .. "but got: %s."):format(v194.name, l_inspect_0(v193.resolveType)));
    return (setmetatable(v194, v83));
end;
v83.getTypes = function(v197)
    if typeof(v197._types) == "function" then
        v197._types = v197._types();
    end;
    return v197._types;
end;
v83.toConfig = function(v198)
    return {
        name = v198.name,
        description = v198.description,
        types = v198:getTypes(),
        resolveType = v198.resolveType,
        extensions = v198.extensions,
        astNode = v198.astNode,
        extensionASTNodes = v198.extensionASTNodes or {}
    };
end;
v83.__tostring = function(v199)
    return v199:toString();
end;
v83.toString = function(v200)
    return v200.name;
end;
v83.toJSON = function(v201)
    return v201:toString();
end;
v71 = function(v202)
    local l_types_0 = v202.types;
    local v204 = if typeof(l_types_0) == "function" then l_types_0() else l_types_0;
    l_devAssert_0(l_Array_0.isArray(v204), ("Must provide Array of types or a function which returns such an array for Union %s."):format(v202.name));
    return v204;
end;
v84.__index = v84;
v84.new = function(v205)
    local v206 = {
        name = v205.name,
        description = v205.description,
        extensions = if not v205.extensions then nil else l_toObjMap_0(v205.extensions),
        astNode = v205.astNode
    };
    local l_extensionASTNodes_4 = v205.extensionASTNodes;
    v206.extensionASTNodes = if not not l_extensionASTNodes_4 and #l_extensionASTNodes_4 > 0 then l_extensionASTNodes_4 else nil;
    v206._values = v74(v206.name, v205.values);
    v206._valueLookup = {};
    l_Array_0.forEach(v206._values, function(v208)
        if v208.value == v208.value then
            v206._valueLookup[v208.value] = v208;
            return ;
        else
            v206._valueLookup[v8] = v208;
            return ;
        end;
    end);
    v206._nameLookup = l_keyMap_0(v206._values, function(v209)
        return v209.name;
    end);
    l_devAssert_0(typeof(v205.name) == "string", "Must provide name.");
    return (setmetatable(v206, v84));
end;
v84.getValues = function(v210)
    return v210._values;
end;
v84.getValue = function(v211, v212)
    return v211._nameLookup[v212];
end;
v84.serialize = function(v213, v214)
    local v215 = nil;
    v215 = if v214 == v214 then v213._valueLookup[v214] else v213._valueLookup[v8];
    if v215 == nil then
        error(l_GraphQLError_0.new(("Enum \"%s\" cannot represent value: %s"):format(v213.name, l_inspect_0(v214))));
    end;
    return v215.name;
end;
v84.parseValue = function(v216, v217)
    if typeof(v217) ~= "string" then
        local v218 = l_inspect_0(v217);
        error(l_GraphQLError_0.new(("Enum \"%s\" cannot represent non-string value: %s." .. v73(v216, v218)):format(v216.name, v218)));
    end;
    local v219 = v216:getValue(v217);
    if v219 == nil then
        error(l_GraphQLError_0.new(("Value \"%s\" does not exist in \"%s\" enum."):format(v217, v216.name) .. v73(v216, v217)));
    end;
    return v219.value;
end;
v84.parseLiteral = function(v220, v221, _)
    if v221.kind ~= l_Kind_0.ENUM then
        local v223 = l_print_0(v221);
        error(l_GraphQLError_0.new(("Enum \"%s\" cannot represent non-enum value: %s."):format(v220.name, v223) .. v73(v220, v223), v221));
    end;
    local v224 = v220:getValue(v221.value);
    if v224 == nil then
        local v225 = l_print_0(v221);
        error(l_GraphQLError_0.new(("Value \"%s\" does not exist in \"%s\" enum."):format(v225, v220.name) .. v73(v220, v225), v221));
    end;
    return v224.value;
end;
v84.toConfig = function(v226)
    return {
        name = v226.name,
        description = v226.description,
        values = l_keyValMap_0(v226:getValues(), function(v227)
            return v227.name;
        end, function(v228)
            return {
                description = v228.description,
                value = v228.value,
                deprecationReason = v228.deprecationReason,
                extensions = v228.extensions,
                astNode = v228.astNode
            };
        end),
        extensions = v226.extensions,
        astNode = v226.astNode,
        extensionASTNodes = v226.extensionASTNodes or {}
    };
end;
v84.__tostring = function(v229)
    return v229:toString();
end;
v84.toString = function(v230)
    return v230.name;
end;
v84.toJSON = function(v231)
    return v231:toString();
end;
v73 = function(v232, v233)
    return l_didYouMean_0("the enum value", (l_suggestionList_0(v233, (l_Array_0.map(v232:getValues(), function(v234)
        return v234.name;
    end)))));
end;
v74 = function(v235, v236)
    l_devAssert_0(v72(v236) or v17(v236, l_Map_0), ("%s values must be an object with value names as keys."):format((tostring(v235))));
    return l_Array_0.map(l_coerceToMap_0(v236):entries(), function(v237)
        local v238 = v237[1];
        local v239 = v237[2];
        l_devAssert_0(v72(v239), ("%s.%s must refer to an object with a \"value\" key "):format(tostring(v235), (tostring(v238))) .. ("representing an internal value but got: %s."):format(l_inspect_0(v239)));
        return {
            name = tostring(v238),
            description = v239.description,
            value = if v239.value ~= nil then v239.value else v238,
            deprecationReason = v239.deprecationReason,
            extensions = if not v239.extensions then nil else l_toObjMap_0(v239.extensions),
            astNode = v239.astNode
        };
    end);
end;
v85.__index = v85;
v85.new = function(v240)
    local v241 = {
        name = v240.name,
        description = v240.description,
        extensions = if not v240.extensions then nil else l_toObjMap_0(v240.extensions),
        astNode = v240.astNode
    };
    local l_extensionASTNodes_5 = v240.extensionASTNodes;
    v241.extensionASTNodes = if not not l_extensionASTNodes_5 and #l_extensionASTNodes_5 > 0 then l_extensionASTNodes_5 else nil;
    v241._fields = function()
        return v70(v240);
    end;
    l_devAssert_0(typeof(v240.name) == "string", "Must provide name.");
    return (setmetatable(v241, v85));
end;
v85.getFields = function(v243)
    if typeof(v243._fields) == "function" then
        v243._fields = v243._fields();
    end;
    return v243._fields;
end;
v85.toConfig = function(v244)
    return {
        name = v244.name,
        description = v244.description,
        fields = l_mapValueOrdered_0(v244:getFields(), function(v245)
            return {
                description = v245.description,
                type = v245.type,
                defaultValue = v245.defaultValue,
                extensions = v245.extensions,
                astNode = v245.astNode
            };
        end),
        extensions = v244.extensions,
        astNode = v244.astNode,
        extensionASTNodes = v244.extensionASTNodes or {}
    };
end;
v85.__tostring = function(v246)
    return v246:toString();
end;
v85.toString = function(v247)
    return v247.name;
end;
v85.toJSON = function(v248)
    return v248:toString();
end;
v70 = function(v249)
    local l_fields_1 = v249.fields;
    local v251 = if typeof(l_fields_1) == "function" then l_fields_1() else l_fields_1;
    l_devAssert_0(v72(v251) or v17(v251, l_Map_0), ("%s fields must be an object with field names as keys or a function which returns such an object."):format(v249.name));
    return l_mapValueOrdered_0(l_coerceToMap_0(v251), function(v252, v253)
        l_devAssert_0(v252.resolve == nil, ("%s.%s field has a resolve property, but Input Types cannot define resolvers."):format(v249.name, v253));
        return {
            name = v253,
            description = v252.description,
            type = v252.type,
            defaultValue = v252.defaultValue,
            deprecationReason = v252.deprecationReason,
            extensions = if not v252.extensions then nil else l_toObjMap_0(v252.extensions),
            astNode = v252.astNode
        };
    end);
end;
v69 = function(v254)
    return v47(v254.type) and v254.defaultValue == nil;
end;
local _ = {
    new = function()
        return {};
    end
};
return {
    GraphQLList = v78,
    GraphQLNonNull = v79,
    GraphQLScalarType = v80,
    GraphQLObjectType = v81,
    GraphQLInterfaceType = v82,
    GraphQLUnionType = v83,
    GraphQLEnumType = v84,
    GraphQLInputObjectType = v85,
    isType = v31,
    assertType = v32,
    isScalarType = v33,
    assertScalarType = v34,
    isObjectType = v35,
    assertObjectType = v36,
    isInterfaceType = v37,
    assertInterfaceType = v38,
    isUnionType = v39,
    assertUnionType = v40,
    isEnumType = v41,
    assertEnumType = v42,
    isInputObjectType = v43,
    assertInputObjectType = v44,
    isListType = v45,
    assertListType = v46,
    isNonNullType = v47,
    assertNonNullType = v48,
    isInputType = v49,
    assertInputType = v50,
    isOutputType = v51,
    assertOutputType = v52,
    isLeafType = v53,
    assertLeafType = v54,
    isCompositeType = v55,
    assertCompositeType = v56,
    isAbstractType = v57,
    assertAbstractType = v58,
    isWrappingType = v59,
    assertWrappingType = v60,
    isNullableType = v61,
    assertNullableType = v62,
    getNullableType = v63,
    isNamedType = v64,
    assertNamedType = v65,
    getNamedType = v66,
    argsToArgsConfig = v67,
    isRequiredArgument = v68,
    isRequiredInputField = v69,
    NULL = v7
};


local v0 = {};
local _ = require(script.Parent.jsutils.Path);
local v2 = require(script.schema);
v0.isSchema = v2.isSchema;
v0.assertSchema = v2.assertSchema;
v0.GraphQLSchema = v2.GraphQLSchema;
local v3 = require(script.definition);
v0.isType = v3.isType;
v0.isScalarType = v3.isScalarType;
v0.isObjectType = v3.isObjectType;
v0.isInterfaceType = v3.isInterfaceType;
v0.isUnionType = v3.isUnionType;
v0.isEnumType = v3.isEnumType;
v0.isInputObjectType = v3.isInputObjectType;
v0.isListType = v3.isListType;
v0.isNonNullType = v3.isNonNullType;
v0.isInputType = v3.isInputType;
v0.isOutputType = v3.isOutputType;
v0.isLeafType = v3.isLeafType;
v0.isCompositeType = v3.isCompositeType;
v0.isAbstractType = v3.isAbstractType;
v0.isWrappingType = v3.isWrappingType;
v0.isNullableType = v3.isNullableType;
v0.isNamedType = v3.isNamedType;
v0.isRequiredArgument = v3.isRequiredArgument;
v0.isRequiredInputField = v3.isRequiredInputField;
v0.assertType = v3.assertType;
v0.assertScalarType = v3.assertScalarType;
v0.assertObjectType = v3.assertObjectType;
v0.assertInterfaceType = v3.assertInterfaceType;
v0.assertUnionType = v3.assertUnionType;
v0.assertEnumType = v3.assertEnumType;
v0.assertInputObjectType = v3.assertInputObjectType;
v0.assertListType = v3.assertListType;
v0.assertNonNullType = v3.assertNonNullType;
v0.assertInputType = v3.assertInputType;
v0.assertOutputType = v3.assertOutputType;
v0.assertLeafType = v3.assertLeafType;
v0.assertCompositeType = v3.assertCompositeType;
v0.assertAbstractType = v3.assertAbstractType;
v0.assertWrappingType = v3.assertWrappingType;
v0.assertNullableType = v3.assertNullableType;
v0.assertNamedType = v3.assertNamedType;
v0.getNullableType = v3.getNullableType;
v0.getNamedType = v3.getNamedType;
v0.GraphQLScalarType = v3.GraphQLScalarType;
v0.GraphQLObjectType = v3.GraphQLObjectType;
v0.GraphQLInterfaceType = v3.GraphQLInterfaceType;
v0.GraphQLUnionType = v3.GraphQLUnionType;
v0.GraphQLEnumType = v3.GraphQLEnumType;
v0.GraphQLInputObjectType = v3.GraphQLInputObjectType;
v0.GraphQLList = v3.GraphQLList;
v0.GraphQLNonNull = v3.GraphQLNonNull;
local v4 = require(script.directives);
v0.isDirective = v4.isDirective;
v0.assertDirective = v4.assertDirective;
v0.GraphQLDirective = v4.GraphQLDirective;
v0.isSpecifiedDirective = v4.isSpecifiedDirective;
v0.specifiedDirectives = v4.specifiedDirectives;
v0.GraphQLIncludeDirective = v4.GraphQLIncludeDirective;
v0.GraphQLSkipDirective = v4.GraphQLSkipDirective;
v0.GraphQLDeprecatedDirective = v4.GraphQLDeprecatedDirective;
v0.GraphQLSpecifiedByDirective = v4.GraphQLSpecifiedByDirective;
v0.DEFAULT_DEPRECATION_REASON = v4.DEFAULT_DEPRECATION_REASON;
local v5 = require(script.scalars);
v0.isSpecifiedScalarType = v5.isSpecifiedScalarType;
v0.specifiedScalarTypes = v5.specifiedScalarTypes;
v0.GraphQLInt = v5.GraphQLInt;
v0.GraphQLFloat = v5.GraphQLFloat;
v0.GraphQLString = v5.GraphQLString;
v0.GraphQLBoolean = v5.GraphQLBoolean;
v0.GraphQLID = v5.GraphQLID;
local v6 = require(script.introspection);
v0.isIntrospectionType = v6.isIntrospectionType;
v0.introspectionTypes = v6.introspectionTypes;
v0.__Schema = v6.__Schema;
v0.__Directive = v6.__Directive;
v0.__DirectiveLocation = v6.__DirectiveLocation;
v0.__Type = v6.__Type;
v0.__Field = v6.__Field;
v0.__InputValue = v6.__InputValue;
v0.__EnumValue = v6.__EnumValue;
v0.__TypeKind = v6.__TypeKind;
v0.TypeKind = v6.TypeKind;
v0.SchemaMetaFieldDef = v6.SchemaMetaFieldDef;
v0.TypeMetaFieldDef = v6.TypeMetaFieldDef;
v0.TypeNameMetaFieldDef = v6.TypeNameMetaFieldDef;
local v7 = require(script.validate);
v0.validateSchema = v7.validateSchema;
v0.assertValidSchema = v7.assertValidSchema;
return v0;