@kiwano/core 2.2.0-beta.2 → 3.0.0-beta.2

package/dist/index.cjs

@@ -0,0 +1,2250 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    SearchFilterPlugin: ()=>SearchFilterPlugin,
+    pluralize: ()=>external_pluralize_default(),
+    graphQLAclMiddleware: ()=>graphQLAclMiddleware,
+    itemsPaginationPlugin: ()=>itemsPaginationPlugin,
+    getAclExtension: ()=>getAclExtension,
+    objectType: ()=>objectType_objectType,
+    defaultAclMiddlewareOptions: ()=>defaultAclMiddlewareOptions,
+    offsetLimitPaginationPlugin: ()=>offsetLimitPaginationPlugin,
+    ObjectTypeBuilder: ()=>ObjectTypeBuilder,
+    DataError: ()=>DataError_DataError,
+    resolveName: ()=>resolveName,
+    searchFilterPlugin: ()=>searchFilterPlugin,
+    ItemsPaginationPlugin: ()=>ItemsPaginationPlugin,
+    FieldBuilder: ()=>FieldBuilder,
+    NotFoundError: ()=>NotFoundError,
+    UpdateInputObjectTypeBuilder: ()=>UpdateInputObjectTypeBuilder,
+    InvalidInputError: ()=>InvalidInputError,
+    CompactNamingStrategy: ()=>CompactNamingStrategy,
+    createInputObjectType: ()=>createInputObjectType,
+    defaultEqualsFilterPluginOptions: ()=>defaultEqualsFilterPluginOptions,
+    getPathResource: ()=>getPathResource,
+    AbstractEntitySchemaBuilder: ()=>AbstractEntitySchemaBuilder,
+    isTypeInput: ()=>isTypeInput,
+    resolveAutoBuilderArgs: ()=>resolveAutoBuilderArgs,
+    PluginError: ()=>PluginError_PluginError,
+    unionType: ()=>unionType_unionType,
+    SortPlugin: ()=>SortPlugin,
+    resolveBuilderArgs: ()=>resolveBuilderArgs,
+    RelayPaginationPlugin: ()=>RelayPaginationPlugin,
+    BuildContext: ()=>BuildContext,
+    resolveType: ()=>resolveType,
+    FinalizeContext: ()=>FinalizeContext,
+    enumType: ()=>enumType_enumType,
+    inputObjectType: ()=>inputObjectType_inputObjectType,
+    SchemaBuilder: ()=>SchemaBuilder,
+    DescriptiveNamingStrategy: ()=>DescriptiveNamingStrategy,
+    lcFirst: ()=>lcFirst,
+    descriptiveNamingStrategy: ()=>descriptiveNamingStrategy,
+    relayPaginationPlugin: ()=>relayPaginationPlugin,
+    defaultSearchFilterPluginOptions: ()=>defaultSearchFilterPluginOptions,
+    sortPlugin: ()=>sortPlugin,
+    ConnectionPaginationPlugin: ()=>ConnectionPaginationPlugin,
+    EnumTypeBuilder: ()=>EnumTypeBuilder,
+    ensureInstantiated: ()=>ensureInstantiated,
+    camelize: ()=>camelize,
+    EntitySchemaBuilder: ()=>EntitySchemaBuilder,
+    enumValue: ()=>enumValue_enumValue,
+    isFieldId: ()=>isFieldId,
+    updateInputObjectType: ()=>updateInputObjectType_updateInputObjectType,
+    EntityFieldType: ()=>entitySchema_EntityFieldType,
+    equalsFilterPlugin: ()=>equalsFilterPlugin,
+    ucFirst: ()=>ucFirst,
+    BuilderError: ()=>BuilderError,
+    EqualsFilterPlugin: ()=>EqualsFilterPlugin,
+    InputObjectTypeBuilder: ()=>InputObjectTypeBuilder,
+    SimplePaginationPlugin: ()=>SimplePaginationPlugin,
+    argument: ()=>argument_argument,
+    aclPlugin: ()=>aclPlugin,
+    EnumValueBuilder: ()=>EnumValueBuilder,
+    entitySchema: ()=>entitySchema_entitySchema,
+    schema: ()=>schema_schema,
+    ForbiddenError: ()=>ForbiddenError_ForbiddenError,
+    AbstractEntitySchemaBuilderBase: ()=>AbstractEntitySchemaBuilderBase,
+    connectionPaginationPlugin: ()=>connectionPaginationPlugin,
+    compactNamingStrategy: ()=>compactNamingStrategy,
+    SortDirection: ()=>sort_SortDirection,
+    defaultAclOptions: ()=>defaultAclOptions,
+    isTypeScalar: ()=>isTypeScalar,
+    AclPlugin: ()=>AclPlugin,
+    default: ()=>ts_rslib_entry_,
+    firstAfterPaginationPlugin: ()=>firstAfterPaginationPlugin,
+    inputField: ()=>inputField_inputField,
+    defaultScalarNames: ()=>defaultScalarNames,
+    ResolverError: ()=>ResolverError,
+    ArgumentBuilder: ()=>ArgumentBuilder,
+    resolveBuilder: ()=>resolveBuilder,
+    CreateInputObjectTypeBuilder: ()=>CreateInputObjectTypeBuilder,
+    InputFieldBuilder: ()=>InputFieldBuilder,
+    AbstractSchemaBuilder: ()=>AbstractSchemaBuilder,
+    OffsetLimitPaginationPlugin: ()=>OffsetLimitPaginationPlugin,
+    FrameworkError: ()=>FrameworkError,
+    UnionTypeBuilder: ()=>UnionTypeBuilder,
+    honoAclMiddleware: ()=>honoAclMiddleware,
+    MultiPlugin: ()=>MultiPlugin,
+    AclAction: ()=>acl_AclAction,
+    FirstAfterPaginationPlugin: ()=>FirstAfterPaginationPlugin,
+    entityFieldTypeExtensionName: ()=>entityFieldTypeExtensionName,
+    defaultSortPluginOptions: ()=>defaultSortPluginOptions,
+    field: ()=>field_field,
+    simplePaginationPlugin: ()=>simplePaginationPlugin
+});
+const compat_namespaceObject = require("es-toolkit/compat");
+const schema_namespaceObject = require("@graphql-tools/schema");
+const external_graphql_middleware_namespaceObject = require("graphql-middleware");
+const external_graphql_namespaceObject = require("graphql");
+class FrameworkError extends Error {
+    constructor(message, developerInfo){
+        super(message);
+        this.name = this.constructor.name;
+        this.developerInfo = developerInfo;
+    }
+}
+const error_FrameworkError = FrameworkError;
+class BuilderError extends error_FrameworkError {
+}
+class Builder {
+    use(...plugins) {
+        plugins.forEach((plugin)=>this._plugins.push(plugin));
+        return this;
+    }
+    async _executePlugins(methodName, fn) {
+        for (const plugin of this._plugins)if (plugin[methodName]) await fn(plugin);
+    }
+    _executePluginsSync(methodName, fn) {
+        for (const plugin of this._plugins)if (plugin[methodName]) fn(plugin);
+    }
+    get name() {
+        return resolveName(this._name);
+    }
+    async finalize(context) {
+        if (this._finalized) return;
+        await this.finalizeBuilder(context);
+        this._finalized = true;
+    }
+    constructor(name = null){
+        this._plugins = [];
+        this._finalized = false;
+        this._name = name;
+    }
+}
+class BuildContext {
+    getType(name) {
+        if (this.resolvedTypes.has(name)) return this.resolvedTypes.get(name);
+        const typeResult = this.schema.locateType(name, false) ?? this.rootSchema.locateType(name, true);
+        if (!typeResult) return null;
+        const { type, schema } = typeResult;
+        let resolvedType = null;
+        if (type instanceof Builder) {
+            let context = this;
+            if (schema != this.schema) context = new BuildContext(schema, this.rootSchema, this.resolvedTypes);
+            resolvedType = type.build(context);
+        } else if (type instanceof external_graphql_namespaceObject.GraphQLScalarType) resolvedType = type;
+        if (!resolvedType) throw new BuilderError(`Type ${name} not found`);
+        this.resolvedTypes.set(name, resolvedType);
+        return resolvedType;
+    }
+    getResolver(typeName, fieldName) {
+        return this.schema.findResolver(typeName, fieldName);
+    }
+    constructor(schema, rootSchema, resolvedTypes){
+        this.schema = schema;
+        this.rootSchema = rootSchema;
+        this.resolvedTypes = resolvedTypes;
+    }
+}
+class FinalizeContext {
+    async getType(name) {
+        const typeResult = this.schema.locateType(name, false) ?? this.rootSchema.locateType(name, true);
+        if (!typeResult) return null;
+        const { type, schema } = typeResult;
+        if (type instanceof Builder) {
+            let context = this;
+            if (schema != this.schema) context = new FinalizeContext(schema, this.rootSchema);
+            await type.finalize(context);
+        }
+        return type;
+    }
+    constructor(schema, rootSchema){
+        this.schema = schema;
+        this.rootSchema = rootSchema;
+    }
+}
+function resolveName(name) {
+    return (0, compat_namespaceObject.isFunction)(name) ? name() : name;
+}
+const definition_namespaceObject = require("graphql/type/definition");
+class EnumValueBuilder extends Builder {
+    value(value) {
+        this._value = value;
+        return this;
+    }
+    description(description) {
+        this._description = description;
+        return this;
+    }
+    extension(name, value) {
+        this._extensions.set(name, value);
+        return this;
+    }
+    async finalizeBuilder(context) {
+        const info = this.info();
+        await this._executePlugins('beforeFinalizeEnumValue', (plugin)=>plugin.beforeFinalizeEnumValue(this, context, info));
+        await this.finalizeEnumValue(context, info);
+        await this._executePlugins('afterFinalizeEnumValue', (plugin)=>plugin.afterFinalizeEnumValue(this, context, info));
+    }
+    async finalizeEnumValue(context, info) {}
+    build(context) {
+        const info = this.info();
+        this._executePluginsSync('beforeBuildEnumValue', (plugin)=>plugin.beforeBuildEnumValue(this, context, info));
+        const enumValue = {
+            value: this._value,
+            description: this._description,
+            extensions: {
+                ...Object.fromEntries(this._extensions)
+            }
+        };
+        this._executePluginsSync('afterBuildEnumValue', (plugin)=>plugin.afterBuildEnumValue(this, context, info, enumValue));
+        return enumValue;
+    }
+    info() {
+        return {
+            name: this.name,
+            value: this._value,
+            description: this._description,
+            extensions: new Map(this._extensions),
+            plugins: (0, compat_namespaceObject.clone)(this._plugins)
+        };
+    }
+    constructor(name, value = null){
+        super(name), this._extensions = new Map();
+        this._value = value;
+    }
+}
+function enumValue_enumValue(name, value = null) {
+    return new EnumValueBuilder(name, value);
+}
+class EnumTypeBuilder extends Builder {
+    description(description) {
+        this._description = description;
+        return this;
+    }
+    extension(name, value) {
+        this._extensions.set(name, value);
+        return this;
+    }
+    value(builderOrName, value = null, configurator = null) {
+        let valueBuilder = null;
+        if (builderOrName instanceof EnumValueBuilder) valueBuilder = builderOrName;
+        else if ((0, compat_namespaceObject.isString)(builderOrName)) {
+            valueBuilder = new EnumValueBuilder(builderOrName, value);
+            if (configurator) configurator(valueBuilder);
+        } else throw new BuilderError('Invalid value provided', builderOrName);
+        this._values.push(valueBuilder);
+        return this;
+    }
+    valuesObject(object) {
+        const keys = Object.keys(object).filter((key)=>isNaN(Number.parseInt(key)));
+        for (const key of keys)this.value(key, object[key]);
+    }
+    async finalizeBuilder(context) {
+        const info = this.info();
+        await this._executePlugins('beforeFinalizeEnumType', (plugin)=>plugin.beforeFinalizeEnumType(this, context, info));
+        await this.finalizeEnumType(context, info);
+        await this._executePlugins('afterFinalizeEnumType', (plugin)=>plugin.afterFinalizeEnumType(this, context, info));
+        for (const value of this._values)this._plugins.forEach((plugin)=>value.use(plugin));
+        for (const value of this._values)await value.finalize(context);
+    }
+    async finalizeEnumType(context, info) {}
+    build(context) {
+        const info = this.info();
+        this._executePluginsSync('beforeBuildEnumType', (plugin)=>plugin.beforeBuildEnumType(this, context, info));
+        const builtValues = {};
+        for (const value of this._values)builtValues[value.name] = value.build(context);
+        const enumType = new definition_namespaceObject.GraphQLEnumType({
+            name: this.name,
+            description: this._description,
+            values: builtValues,
+            extensions: {
+                ...Object.fromEntries(this._extensions)
+            }
+        });
+        this._executePluginsSync('afterBuildEnumType', (plugin)=>plugin.afterBuildEnumType(this, context, info, enumType));
+        return enumType;
+    }
+    info() {
+        return {
+            name: this.name,
+            description: this._description,
+            values: (0, compat_namespaceObject.clone)(this._values),
+            extensions: new Map(this._extensions),
+            plugins: (0, compat_namespaceObject.clone)(this._plugins)
+        };
+    }
+    constructor(name, valuesObject = null){
+        super(name), this._values = [], this._extensions = new Map();
+        if (valuesObject) this.valuesObject(valuesObject);
+    }
+}
+function enumType_enumType(name, valuesObject = null) {
+    return new EnumTypeBuilder(name, valuesObject);
+}
+const ts_enumType = enumType_enumType;
+class InputFieldBuilder extends Builder {
+    type(type) {
+        const resolvedType = resolveType(type);
+        this._type = resolvedType.type;
+        if (resolvedType.nonNull) this.nonNull();
+        if (resolvedType.list) this.list();
+        if (resolvedType.nonNullList) this.nonNullList();
+        return this;
+    }
+    description(description) {
+        this._description = description;
+        return this;
+    }
+    extension(name, value) {
+        this._extensions.set(name, value);
+        return this;
+    }
+    nonNull(nonNull = true) {
+        this._nonNull = nonNull;
+        return this;
+    }
+    list(list = true) {
+        this._list = list;
+        return this;
+    }
+    nonNullList(nonNullList = true) {
+        if (nonNullList) this.list();
+        this._nonNullList = nonNullList;
+        return this;
+    }
+    async finalizeBuilder(context) {
+        const info = this.info();
+        await this._executePlugins('beforeFinalizeInputField', (plugin)=>plugin.beforeFinalizeInputField(this, context, info));
+        await this.finalizeInputField(context, info);
+        await this._executePlugins('afterFinalizeInputField', (plugin)=>plugin.afterFinalizeInputField(this, context, info));
+    }
+    async finalizeInputField(context, info) {}
+    build(context) {
+        const info = this.info();
+        this._executePluginsSync('beforeBuildInputField', (plugin)=>plugin.beforeBuildInputField(this, context, info));
+        let type = (0, compat_namespaceObject.isString)(this._type) ? context.getType(this._type) : this._type;
+        if (this._list) {
+            if (this._nonNullList) type = new external_graphql_namespaceObject.GraphQLNonNull(type);
+            type = new external_graphql_namespaceObject.GraphQLList(type);
+        }
+        if (this._nonNull) type = new external_graphql_namespaceObject.GraphQLNonNull(type);
+        const inputField = {
+            type,
+            description: this._description,
+            extensions: {
+                ...Object.fromEntries(this._extensions)
+            }
+        };
+        this._executePluginsSync('afterBuildInputField', (plugin)=>plugin.afterBuildInputField(this, context, info, inputField));
+        return inputField;
+    }
+    info() {
+        return {
+            name: this.name,
+            type: this._type,
+            description: this._description,
+            extensions: new Map(this._extensions),
+            nonNull: this._nonNull,
+            nonNullList: this._nonNullList,
+            list: this._list,
+            plugins: (0, compat_namespaceObject.clone)(this._plugins)
+        };
+    }
+    constructor(name, type){
+        super(name), this._extensions = new Map(), this._nonNull = false, this._nonNullList = false, this._list = false;
+        this.type(type);
+    }
+}
+function inputField_inputField(name, type) {
+    return new InputFieldBuilder(name, type);
+}
+class InputObjectTypeBuilder extends Builder {
+    description(description) {
+        this._description = description;
+        return this;
+    }
+    extension(name, value) {
+        this._extensions.set(name, value);
+        return this;
+    }
+    field(fieldOrName, type = null, configurator = null) {
+        let field = null;
+        if (fieldOrName instanceof InputFieldBuilder) field = fieldOrName;
+        else if ((0, compat_namespaceObject.isString)(fieldOrName) && type) {
+            field = new InputFieldBuilder(fieldOrName, type);
+            if (configurator) configurator(field);
+        } else throw new BuilderError('Invalid input field provided', fieldOrName);
+        this._fields.push(field);
+        return this;
+    }
+    async finalizeBuilder(context) {
+        const info = this.info();
+        await this._executePlugins('beforeFinalizeInputObjectType', (plugin)=>plugin.beforeFinalizeInputObjectType(this, context, info));
+        await this.finalizeInputObjectType(context, info);
+        await this._executePlugins('afterFinalizeInputObjectType', (plugin)=>plugin.afterFinalizeInputObjectType(this, context, info));
+        for (const field of this._fields)this._plugins.forEach((plugin)=>field.use(plugin));
+        for (const field of this._fields)await field.finalize(context);
+    }
+    async finalizeInputObjectType(context, info) {}
+    build(context) {
+        const info = this.info();
+        this._executePluginsSync('beforeBuildInputObjectType', (plugin)=>plugin.beforeBuildInputObjectType(this, context, info));
+        const inputObjectType = new external_graphql_namespaceObject.GraphQLInputObjectType({
+            name: this.name,
+            description: this._description,
+            extensions: {
+                ...Object.fromEntries(this._extensions)
+            },
+            fields: ()=>{
+                const builtFields = {};
+                for (const field of this._fields)builtFields[field.name] = field.build(context);
+                return builtFields;
+            }
+        });
+        this._executePluginsSync('afterBuildInputObjectType', (plugin)=>plugin.afterBuildInputObjectType(this, context, info, inputObjectType));
+        return inputObjectType;
+    }
+    info() {
+        return {
+            name: this.name,
+            description: this._description,
+            fields: (0, compat_namespaceObject.clone)(this._fields),
+            extensions: new Map(this._extensions),
+            plugins: (0, compat_namespaceObject.clone)(this._plugins)
+        };
+    }
+    constructor(...args){
+        super(...args), this._fields = [], this._extensions = new Map();
+    }
+}
+function inputObjectType_inputObjectType(name) {
+    return new InputObjectTypeBuilder(name);
+}
+const ts_inputObjectType = inputObjectType_inputObjectType;
+const defaultScalarNames = [
+    'Int',
+    'Float',
+    'String',
+    'Boolean',
+    'ID'
+];
+function resolveAutoBuilderArgs(builderOrConfiguratorOrName, configuratorArg, builderType) {
+    let builder = null;
+    let name = null;
+    let configurator = null;
+    if (builderOrConfiguratorOrName instanceof builderType) {
+        builder = builderOrConfiguratorOrName;
+        configurator = configuratorArg;
+    } else if ((0, compat_namespaceObject.isString)(builderOrConfiguratorOrName)) {
+        name = builderOrConfiguratorOrName;
+        configurator = configuratorArg;
+    } else configurator = builderOrConfiguratorOrName;
+    return {
+        builder,
+        name,
+        configurator
+    };
+}
+function resolveBuilderArgs(builderOrName, configuratorArg, builderType) {
+    let builder = null;
+    let name = null;
+    let configurator = null;
+    if (builderOrName instanceof builderType) {
+        builder = builderOrName;
+        configurator = configuratorArg;
+    } else if ((0, compat_namespaceObject.isString)(builderOrName)) {
+        name = builderOrName;
+        configurator = configuratorArg;
+    }
+    return {
+        builder,
+        name,
+        configurator
+    };
+}
+function resolveBuilder(args, defaultBuilderGenerator) {
+    let resolvedBuilder = args.builder;
+    if (!resolvedBuilder) resolvedBuilder = defaultBuilderGenerator(args.name);
+    if (args.configurator) args.configurator(resolvedBuilder);
+    return resolvedBuilder;
+}
+const nonNullTypePattern = /(.+)!$/;
+const nonNullListTypePattern = /\[(.+)!]/;
+const listTypePattern = /\[(.+)]/;
+const baseTypePattern = /\[?(\w+)]?!?/;
+function resolveType(type) {
+    if (!(0, compat_namespaceObject.isString)(type)) return {
+        type,
+        nonNull: false,
+        nonNullList: false,
+        list: false
+    };
+    const nonNull = nonNullTypePattern.test(type);
+    const nonNullList = nonNullListTypePattern.test(type);
+    const list = listTypePattern.test(type);
+    const baseMatches = baseTypePattern.exec(type);
+    return {
+        nonNull,
+        list,
+        nonNullList,
+        type: baseMatches[1]
+    };
+}
+function isTypeInput(type, schema) {
+    if ((0, compat_namespaceObject.isString)(type)) {
+        const typeName = type;
+        if (defaultScalarNames.indexOf(typeName) >= 0) return true;
+        {
+            const builderType = schema.findType(typeName, true);
+            if (builderType && (builderType instanceof EnumTypeBuilder || builderType instanceof external_graphql_namespaceObject.GraphQLScalarType || builderType instanceof InputObjectTypeBuilder)) return true;
+        }
+    } else if (type instanceof external_graphql_namespaceObject.GraphQLScalarType || type instanceof definition_namespaceObject.GraphQLEnumType) return true;
+    return false;
+}
+function isTypeScalar(type, schema) {
+    if ((0, compat_namespaceObject.isString)(type)) {
+        const typeName = type;
+        if (defaultScalarNames.indexOf(typeName) >= 0) return true;
+        {
+            const builderType = schema.findType(typeName, true);
+            if (builderType && builderType instanceof external_graphql_namespaceObject.GraphQLScalarType) return true;
+        }
+    } else if (type instanceof external_graphql_namespaceObject.GraphQLScalarType) return true;
+    return false;
+}
+function isFieldId(info) {
+    return 'ID' === info.type && 'id' === info.name;
+}
+function ensureInstantiated(input, ...args) {
+    if ((0, compat_namespaceObject.isFunction)(input)) try {
+        const inputClass = input;
+        return new inputClass(...args);
+    } catch  {}
+    return input;
+}
+function getAclExtension(allowed, denied) {
+    return {
+        allowedRoles: Array.from(allowed).join(','),
+        deniedRoles: Array.from(denied).join(',')
+    };
+}
+function camelize(text) {
+    return text.replace(/^([A-Z])|[\s-_]+(\w)/g, (match, p1, p2)=>{
+        if (p2) return p2.toUpperCase();
+        return p1.toLowerCase();
+    });
+}
+class ArgumentBuilder extends Builder {
+    type(type) {
+        const resolvedType = resolveType(type);
+        this._type = resolvedType.type;
+        if (resolvedType.nonNull) this.nonNull();
+        if (resolvedType.list) this.list();
+        if (resolvedType.nonNullList) this.nonNullList();
+        return this;
+    }
+    description(description) {
+        this._description = description;
+        return this;
+    }
+    extension(name, value) {
+        this._extensions.set(name, value);
+        return this;
+    }
+    nonNull(nonNull = true) {
+        this._nonNull = nonNull;
+        return this;
+    }
+    list(list = true) {
+        this._list = list;
+        return this;
+    }
+    nonNullList(nonNullList = true) {
+        if (nonNullList) this.list();
+        this._nonNullList = nonNullList;
+        return this;
+    }
+    async finalizeBuilder(context) {
+        const info = this.info();
+        await this._executePlugins('beforeFinalizeArgument', (plugin)=>plugin.beforeFinalizeArgument(this, context, info));
+        await this.finalizeArgument(context, info);
+        await this._executePlugins('afterFinalizeArgument', (plugin)=>plugin.afterFinalizeArgument(this, context, info));
+    }
+    async finalizeArgument(context, info) {}
+    build(context) {
+        const info = this.info();
+        this._executePluginsSync('beforeBuildArgument', (plugin)=>plugin.beforeBuildArgument(this, context, info));
+        let type = (0, compat_namespaceObject.isString)(this._type) ? context.getType(this._type) : this._type;
+        if (this._list) {
+            if (this._nonNullList) type = new external_graphql_namespaceObject.GraphQLNonNull(type);
+            type = new external_graphql_namespaceObject.GraphQLList(type);
+        }
+        if (this._nonNull) type = new external_graphql_namespaceObject.GraphQLNonNull(type);
+        const argument = {
+            type,
+            description: this._description,
+            extensions: {
+                ...Object.fromEntries(this._extensions)
+            }
+        };
+        this._executePluginsSync('afterBuildArgument', (plugin)=>plugin.afterBuildArgument(this, context, info, argument));
+        return argument;
+    }
+    info() {
+        return {
+            name: this.name,
+            type: this._type,
+            description: this._description,
+            extensions: new Map(this._extensions),
+            nonNull: this._nonNull,
+            nonNullList: this._nonNullList,
+            list: this._list,
+            plugins: (0, compat_namespaceObject.clone)(this._plugins)
+        };
+    }
+    constructor(name, type){
+        super(name), this._extensions = new Map(), this._nonNull = false, this._nonNullList = false, this._list = false;
+        this.type(type);
+    }
+}
+function argument_argument(name, type) {
+    return new ArgumentBuilder(name, type);
+}
+class FieldBuilder extends Builder {
+    type(type) {
+        const resolvedType = resolveType(type);
+        this._type = resolvedType.type;
+        if (resolvedType.nonNull) this.nonNull();
+        if (resolvedType.list) this.list();
+        if (resolvedType.nonNullList) this.nonNullList();
+        return this;
+    }
+    description(description) {
+        this._description = description;
+        return this;
+    }
+    extension(name, value) {
+        this._extensions.set(name, value);
+        return this;
+    }
+    arg(argOrName, type = null, configurator = null) {
+        let argument = null;
+        if (argOrName instanceof ArgumentBuilder) argument = argOrName;
+        else if ((0, compat_namespaceObject.isString)(argOrName) && type) {
+            argument = new ArgumentBuilder(argOrName, type);
+            if (configurator) configurator(argument);
+        } else throw new BuilderError('Invalid argument provided', argOrName);
+        this._arguments.push(argument);
+        return this;
+    }
+    nonNull(nonNull = true) {
+        this._nonNull = nonNull;
+        return this;
+    }
+    list(list = true) {
+        this._list = list;
+        return this;
+    }
+    nonNullList(nonNullList = true) {
+        if (nonNullList) this.list();
+        this._nonNullList = nonNullList;
+        return this;
+    }
+    resolver(resolver) {
+        this._resolver = resolver;
+        return this;
+    }
+    allow(...roles) {
+        roles.forEach((role)=>this._allowedRoles.add(role));
+        return this;
+    }
+    deny(...roles) {
+        roles.forEach((role)=>this._deniedRoles.add(role));
+        return this;
+    }
+    includeDeleted(includeDeleted = true) {
+        this._includeDeleted = includeDeleted;
+        return this;
+    }
+    async finalizeBuilder(context) {
+        const info = this.info();
+        await this._executePlugins('beforeFinalizeField', (plugin)=>plugin.beforeFinalizeField(this, context, info));
+        await this.finalizeField(context, info);
+        await this._executePlugins('afterFinalizeField', (plugin)=>plugin.afterFinalizeField(this, context, info));
+        for (const arg of this._arguments)this._plugins.forEach((plugin)=>arg.use(plugin));
+        for (const argument of this._arguments)await argument.finalize(context);
+    }
+    async finalizeField(context, info) {}
+    build(context, parentBuilder) {
+        if (!parentBuilder) throw new BuilderError('Build: Field needs parent builder argument to be present');
+        const info = this.info();
+        this._executePluginsSync('beforeBuildField', (plugin)=>plugin.beforeBuildField(this, context, info));
+        const builtArgs = {};
+        for (const arg of this._arguments)builtArgs[arg.name] = arg.build(context);
+        let type = (0, compat_namespaceObject.isString)(this._type) ? context.getType(this._type) : this._type;
+        if (null === type) throw new BuilderError(`Type "${this._type}" of field "${this.name}" not found`);
+        if (this._list) {
+            if (this._nonNullList) type = new external_graphql_namespaceObject.GraphQLNonNull(type);
+            type = new external_graphql_namespaceObject.GraphQLList(type);
+        }
+        if (this._nonNull) type = new external_graphql_namespaceObject.GraphQLNonNull(type);
+        const resolver = this._resolver || context.getResolver(parentBuilder.name, this.name);
+        const field = {
+            type,
+            description: this._description,
+            args: builtArgs,
+            extensions: {
+                ...getAclExtension(this._allowedRoles, this._deniedRoles),
+                ...Object.fromEntries(this._extensions)
+            },
+            resolve: resolver
+        };
+        this._executePluginsSync('afterBuildField', (plugin)=>plugin.afterBuildField(this, context, info, field));
+        return field;
+    }
+    info() {
+        return {
+            name: this.name,
+            type: this._type,
+            description: this._description,
+            arguments: (0, compat_namespaceObject.clone)(this._arguments),
+            extensions: new Map(this._extensions),
+            nonNull: this._nonNull,
+            nonNullList: this._nonNullList,
+            list: this._list,
+            includeDeleted: this._includeDeleted,
+            allowedRoles: new Set(this._allowedRoles),
+            deniedRoles: new Set(this._deniedRoles),
+            resolver: this._resolver,
+            plugins: (0, compat_namespaceObject.clone)(this._plugins)
+        };
+    }
+    constructor(name, type = null){
+        super(name), this._arguments = [], this._extensions = new Map(), this._nonNull = false, this._nonNullList = false, this._list = false, this._includeDeleted = false, this._allowedRoles = new Set(), this._deniedRoles = new Set();
+        this.type(type);
+    }
+}
+function field_field(name, type = null) {
+    return new FieldBuilder(name, type);
+}
+class ObjectTypeBuilder extends Builder {
+    description(description) {
+        this._description = description;
+        return this;
+    }
+    extension(name, value) {
+        this._extensions.set(name, value);
+        return this;
+    }
+    resolvers(resolvers) {
+        this._resolvers = resolvers;
+        return this;
+    }
+    getResolvers() {
+        return this._resolvers;
+    }
+    field(fieldOrName, type = null, configurator = null) {
+        let field = null;
+        if (fieldOrName instanceof FieldBuilder) field = fieldOrName;
+        else if ((0, compat_namespaceObject.isString)(fieldOrName) && type) {
+            field = new FieldBuilder(fieldOrName, type);
+            if (configurator) configurator(field);
+        } else throw new BuilderError('Invalid field provided', fieldOrName);
+        this._fields.push(field);
+        return this;
+    }
+    allow(...roles) {
+        roles.forEach((role)=>this._allowedRoles.add(role));
+        return this;
+    }
+    deny(...roles) {
+        roles.forEach((role)=>this._deniedRoles.add(role));
+        return this;
+    }
+    async finalizeBuilder(context) {
+        const info = this.info();
+        await this._executePlugins('beforeFinalizeObjectType', (plugin)=>plugin.beforeFinalizeObjectType(this, context, info));
+        await this.finalizeObjectType(context, info);
+        await this._executePlugins('afterFinalizeObjectType', (plugin)=>plugin.afterFinalizeObjectType(this, context, info));
+        for (const field of this._fields)this._plugins.forEach((plugin)=>field.use(plugin));
+        for (const field of this._fields)await field.finalize(context);
+    }
+    async finalizeObjectType(context, info) {}
+    build(context) {
+        const info = this.info();
+        this._executePluginsSync('beforeBuildObjectType', (plugin)=>plugin.beforeBuildObjectType(this, context, info));
+        const objectType = new external_graphql_namespaceObject.GraphQLObjectType({
+            name: this.name,
+            description: this._description,
+            extensions: {
+                ...getAclExtension(this._allowedRoles, this._deniedRoles),
+                ...Object.fromEntries(this._extensions)
+            },
+            fields: ()=>{
+                const builtFields = {};
+                for (const field of this._fields)builtFields[field.name] = field.build(context, this);
+                return builtFields;
+            }
+        });
+        this._executePluginsSync('afterBuildObjectType', (plugin)=>plugin.afterBuildObjectType(this, context, info, objectType));
+        return objectType;
+    }
+    info() {
+        return {
+            name: this.name,
+            description: this._description,
+            fields: (0, compat_namespaceObject.clone)(this._fields),
+            extensions: new Map(this._extensions),
+            allowedRoles: new Set(this._allowedRoles),
+            deniedRoles: new Set(this._deniedRoles),
+            resolvers: this._resolvers,
+            plugins: (0, compat_namespaceObject.clone)(this._plugins)
+        };
+    }
+    constructor(...args){
+        super(...args), this._fields = [], this._extensions = new Map(), this._allowedRoles = new Set(), this._deniedRoles = new Set();
+    }
+}
+function objectType_objectType(name) {
+    return new ObjectTypeBuilder(name);
+}
+const ts_objectType = objectType_objectType;
+class UnionTypeBuilder extends Builder {
+    type(...types) {
+        types.forEach((role)=>this._types.add(role));
+        return this;
+    }
+    description(description) {
+        this._description = description;
+        return this;
+    }
+    extension(name, value) {
+        this._extensions.set(name, value);
+        return this;
+    }
+    async finalizeBuilder(context) {
+        const info = this.info();
+        await this._executePlugins('beforeFinalizeUnionType', (plugin)=>plugin.beforeFinalizeUnionType(this, context, info));
+        await this.finalizeUnionType(context, info);
+        await this._executePlugins('afterFinalizeUnionType', (plugin)=>plugin.afterFinalizeUnionType(this, context, info));
+    }
+    async finalizeUnionType(context, info) {}
+    build(context) {
+        const info = this.info();
+        this._executePluginsSync('beforeBuildUnionType', (plugin)=>plugin.beforeBuildUnionType(this, context, info));
+        const unionType = new definition_namespaceObject.GraphQLUnionType({
+            name: this.name,
+            description: this._description,
+            types: ()=>{
+                const resolvedTypes = [];
+                for (const type of this._types)if ((0, compat_namespaceObject.isString)(type)) {
+                    const resolved = context.getType(type);
+                    resolvedTypes.push(resolved);
+                } else resolvedTypes.push(type);
+                return resolvedTypes;
+            },
+            extensions: {
+                ...Object.fromEntries(this._extensions)
+            }
+        });
+        this._executePluginsSync('afterBuildUnionType', (plugin)=>plugin.afterBuildUnionType(this, context, info, unionType));
+        return unionType;
+    }
+    info() {
+        return {
+            name: this.name,
+            types: new Set(this._types),
+            description: this._description,
+            extensions: new Map(this._extensions),
+            plugins: (0, compat_namespaceObject.clone)(this._plugins)
+        };
+    }
+    constructor(name, types = null){
+        super(name), this._extensions = new Map();
+        this._types = new Set(types || []);
+    }
+}
+function unionType_unionType(name, types = null) {
+    return new UnionTypeBuilder(name, types);
+}
+const DefaultScalars = [
+    external_graphql_namespaceObject.GraphQLInt,
+    external_graphql_namespaceObject.GraphQLFloat,
+    external_graphql_namespaceObject.GraphQLString,
+    external_graphql_namespaceObject.GraphQLBoolean,
+    external_graphql_namespaceObject.GraphQLID
+];
+class AbstractSchemaBuilder {
+    naming(strategy) {
+        this._namingStrategy = strategy;
+        return this;
+    }
+    setDefaultNamingStrategy(strategy) {
+        this._defaultNamingStrategy = strategy;
+    }
+    get namingStrategy() {
+        return this._namingStrategy || this._defaultNamingStrategy;
+    }
+    customConfig(config) {
+        this._customConfig = config;
+        return this;
+    }
+    object(objectOrName, configurator = null) {
+        const resolvedArgs = resolveBuilderArgs(objectOrName, configurator, ObjectTypeBuilder);
+        const resolvedBuilder = resolveBuilder(resolvedArgs, (name)=>new ObjectTypeBuilder(name));
+        this._objectTypes.set(resolvedBuilder.name, resolvedBuilder);
+        return this;
+    }
+    getObjectTypes() {
+        return (0, compat_namespaceObject.compact)([
+            this._queryObject,
+            this._mutationObject,
+            ...Array.from(this._objectTypes.values())
+        ]);
+    }
+    inputObject(objectOrName, configurator = null) {
+        const resolvedArgs = resolveBuilderArgs(objectOrName, configurator, InputObjectTypeBuilder);
+        const resolvedBuilder = resolveBuilder(resolvedArgs, (name)=>new InputObjectTypeBuilder(name));
+        this._inputObjectTypes.set(resolvedBuilder.name, resolvedBuilder);
+        return this;
+    }
+    getInputObjectTypes() {
+        return Array.from(this._inputObjectTypes.values());
+    }
+    enum(enumOrName, configuratorOrValuesObject = null) {
+        let builder = null;
+        let name = null;
+        let configurator = null;
+        let valuesObject = null;
+        if (enumOrName instanceof EnumTypeBuilder) {
+            builder = enumOrName;
+            if ((0, compat_namespaceObject.isFunction)(configuratorOrValuesObject)) configurator = configuratorOrValuesObject;
+        } else if ((0, compat_namespaceObject.isString)(enumOrName)) {
+            name = enumOrName;
+            if ((0, compat_namespaceObject.isFunction)(configuratorOrValuesObject)) configurator = configuratorOrValuesObject;
+            else valuesObject = configuratorOrValuesObject;
+        }
+        const resolvedArgs = {
+            builder,
+            name,
+            configurator
+        };
+        const resolvedBuilder = resolveBuilder(resolvedArgs, (name)=>new EnumTypeBuilder(name, valuesObject));
+        this._enumTypes.set(resolvedBuilder.name, resolvedBuilder);
+        return this;
+    }
+    getEnumTypes() {
+        return Array.from(this._enumTypes.values());
+    }
+    union(objectOrName, configuratorOrTypes = null) {
+        let builder = null;
+        let name = null;
+        let configurator = null;
+        let resolvedTypes = null;
+        if (objectOrName instanceof UnionTypeBuilder) {
+            builder = objectOrName;
+            if ((0, compat_namespaceObject.isFunction)(configuratorOrTypes)) configurator = configuratorOrTypes;
+        } else if ((0, compat_namespaceObject.isString)(objectOrName)) {
+            name = objectOrName;
+            if ((0, compat_namespaceObject.isFunction)(configuratorOrTypes)) configurator = configuratorOrTypes;
+            else if ((0, compat_namespaceObject.isArray)(configuratorOrTypes)) resolvedTypes = configuratorOrTypes;
+        }
+        const resolvedArgs = {
+            builder,
+            name,
+            configurator
+        };
+        const resolvedBuilder = resolveBuilder(resolvedArgs, (name)=>new UnionTypeBuilder(name, resolvedTypes));
+        this._unionTypes.set(resolvedBuilder.name, resolvedBuilder);
+        return this;
+    }
+    getUnionTypes() {
+        return Array.from(this._unionTypes.values());
+    }
+    scalar(scalar) {
+        this._scalarTypes.set(scalar.name, scalar);
+        return this;
+    }
+    query(fieldOrName, type = null, configurator = null) {
+        this._queryObject.field(fieldOrName, type, configurator);
+        return this;
+    }
+    mutation(fieldOrName, type = null, configurator = null) {
+        if (!this._mutationObject) this._mutationObject = new ObjectTypeBuilder('Mutation');
+        this._mutationObject.field(fieldOrName, type, configurator);
+        return this;
+    }
+    resolvers(resolvers) {
+        this._resolvers = resolvers;
+        return this;
+    }
+    queryResolvers(resolvers) {
+        this._queryResolvers = resolvers;
+        return this;
+    }
+    mutationResolvers(resolvers) {
+        this._mutationResolvers = resolvers;
+        return this;
+    }
+    allow(...roles) {
+        roles.forEach((role)=>this._allowedRoles.add(role));
+        return this;
+    }
+    deny(...roles) {
+        roles.forEach((role)=>this._deniedRoles.add(role));
+        return this;
+    }
+    allowQuery(...roles) {
+        roles.forEach((role)=>this._allowedQueryRoles.add(role));
+        return this;
+    }
+    denyQuery(...roles) {
+        roles.forEach((role)=>this._deniedQueryRoles.add(role));
+        return this;
+    }
+    allowMutation(...roles) {
+        roles.forEach((role)=>this._allowedMutationRoles.add(role));
+        return this;
+    }
+    denyMutation(...roles) {
+        roles.forEach((role)=>this._deniedMutationRoles.add(role));
+        return this;
+    }
+    merge(schema) {
+        this._subSchemas.push(schema);
+        return this;
+    }
+    use(...middlewareOrPlugins) {
+        for (const item of middlewareOrPlugins)if ((0, compat_namespaceObject.isObjectLike)(item)) this._plugins.push(item);
+        else if ((0, compat_namespaceObject.isFunction)(item)) this._middleware.push(item);
+        return this;
+    }
+    findType(name, deep = false) {
+        var _this_locateType;
+        return null === (_this_locateType = this.locateType(name, deep)) || void 0 === _this_locateType ? void 0 : _this_locateType.type;
+    }
+    locateType(name, deep = false) {
+        var _this__mutationObject;
+        let type = null;
+        type = name === this._queryObject.name ? this._queryObject : name === (null === (_this__mutationObject = this._mutationObject) || void 0 === _this__mutationObject ? void 0 : _this__mutationObject.name) ? this._mutationObject : this._objectTypes.get(name) ?? this._inputObjectTypes.get(name) ?? this._enumTypes.get(name) ?? this._unionTypes.get(name) ?? this._scalarTypes.get(name) ?? null;
+        if (!type && deep) for (const sub of this._subSchemas){
+            const result = sub.locateType(name, true);
+            if (result) return result;
+        }
+        return type ? {
+            schema: this,
+            type
+        } : null;
+    }
+    hasType(name, deep = false) {
+        return !!this.findType(name, deep);
+    }
+    findResolver(typeName, fieldName) {
+        const resolvers = this.compiledResolvers;
+        let resolver = null;
+        const typeResolvers = resolvers[typeName];
+        if (typeResolvers && typeResolvers[fieldName]) resolver = typeResolvers[fieldName].bind(typeResolvers);
+        return resolver;
+    }
+    get name() {
+        return resolveName(this._name);
+    }
+    get tag() {
+        return this._tag;
+    }
+    async finalize(rootSchema) {
+        const resolvedRootSchema = rootSchema || this;
+        if (this._namingStrategy) for (const subSchema of this._subSchemas)subSchema.setDefaultNamingStrategy(this._namingStrategy);
+        for (const subSchema of this._subSchemas){
+            this._plugins.forEach((plugin)=>subSchema.use(plugin));
+            this._middleware.forEach((middleware)=>subSchema.use(middleware));
+            subSchema.allow(...Array.from(this._allowedRoles));
+            subSchema.deny(...Array.from(this._deniedRoles));
+            subSchema.allowQuery(...Array.from(this._allowedQueryRoles));
+            subSchema.denyQuery(...Array.from(this._deniedQueryRoles));
+            subSchema.allowMutation(...Array.from(this._allowedMutationRoles));
+            subSchema.denyMutation(...Array.from(this._deniedMutationRoles));
+        }
+        await this._executePlugins('beforeFinalizeSchema', (plugin)=>plugin.beforeFinalizeSchema(this));
+        await this.finalizeSchema();
+        await this._executePlugins('afterFinalizeSchema', (plugin)=>plugin.afterFinalizeSchema(this));
+        for (const objectType of this.getObjectTypes())this._plugins.forEach((plugin)=>objectType.use(plugin));
+        for (const inputObject of this._inputObjectTypes.values())this._plugins.forEach((plugin)=>inputObject.use(plugin));
+        for (const unionType of this._unionTypes.values())this._plugins.forEach((plugin)=>unionType.use(plugin));
+        for (const enumType of this._enumTypes.values())this._plugins.forEach((plugin)=>enumType.use(plugin));
+        for (const objectType of Array.from(this._objectTypes.values()))objectType.allow(...Array.from(this._allowedRoles)).deny(...Array.from(this._deniedRoles));
+        const fullAllowedQueryRoles = [
+            ...Array.from(this._allowedRoles),
+            ...Array.from(this._allowedQueryRoles)
+        ];
+        const fullDeniedQueryRoles = [
+            ...Array.from(this._deniedRoles),
+            ...Array.from(this._deniedQueryRoles)
+        ];
+        for (const queryField of this._queryObject.info().fields)queryField.allow(...fullAllowedQueryRoles).deny(...fullDeniedQueryRoles);
+        if (this._mutationObject) {
+            const fullAllowedMutationRoles = [
+                ...Array.from(this._allowedRoles),
+                ...Array.from(this._allowedMutationRoles)
+            ];
+            const fullDeniedMutationRoles = [
+                ...Array.from(this._deniedRoles),
+                ...Array.from(this._deniedMutationRoles)
+            ];
+            for (const mutationField of this._mutationObject.info().fields)mutationField.allow(...fullAllowedMutationRoles).deny(...fullDeniedMutationRoles);
+        }
+        const finalizeContext = new FinalizeContext(this, resolvedRootSchema);
+        for (const objectType of this.getObjectTypes())await objectType.finalize(finalizeContext);
+        for (const inputObjectType of this._inputObjectTypes.values())await inputObjectType.finalize(finalizeContext);
+        for (const unionType of this._unionTypes.values())await unionType.finalize(finalizeContext);
+        for (const enumType of this._enumTypes.values())await enumType.finalize(finalizeContext);
+        for (const subSchema of this._subSchemas)await subSchema.finalize(resolvedRootSchema);
+    }
+    async finalizeSchema() {}
+    async build() {
+        await this.finalize();
+        this._executePluginsSync('beforeBuild', (plugin)=>plugin.beforeBuild(this));
+        const resolvedTypes = new Map();
+        const schema = await this.buildSchema(resolvedTypes);
+        this._executePluginsSync('afterBuild', (plugin)=>plugin.afterBuild(this, schema));
+        return schema;
+    }
+    async buildSchema(resolvedTypes, rootSchema) {
+        const resolvedRootSchema = rootSchema || this;
+        this._executePluginsSync('beforeBuildSchema', (plugin)=>plugin.beforeBuildSchema(this, resolvedRootSchema));
+        const context = new BuildContext(this, resolvedRootSchema, resolvedTypes);
+        const schemaConfig = {
+            ...this._customConfig || {},
+            query: this._queryObject.build(context)
+        };
+        if (this._mutationObject) schemaConfig['mutation'] = this._mutationObject.build(context);
+        const schema = new external_graphql_namespaceObject.GraphQLSchema(schemaConfig);
+        const fullSchema = (0, external_graphql_middleware_namespaceObject.applyMiddleware)(schema, ...this._middleware);
+        const builtSubSchemas = [];
+        for (const subSchema of this._subSchemas){
+            const builtSchema = await subSchema.buildSchema(resolvedTypes, resolvedRootSchema);
+            builtSubSchemas.push(builtSchema);
+        }
+        const mergedSchema = (0, schema_namespaceObject.mergeSchemas)({
+            schemas: [
+                fullSchema,
+                ...builtSubSchemas
+            ]
+        });
+        this._executePluginsSync('afterBuildSchema', (plugin)=>plugin.afterBuildSchema(this, mergedSchema, resolvedRootSchema));
+        return mergedSchema;
+    }
+    get compiledResolvers() {
+        const resolvers = this._resolvers ? (0, compat_namespaceObject.clone)(this._resolvers) : {};
+        if (this._queryResolvers) resolvers['Query'] = ensureInstantiated(this._queryResolvers);
+        if (this._mutationResolvers && this._mutationObject) resolvers['Mutation'] = ensureInstantiated(this._mutationResolvers);
+        for (const objectType of this._objectTypes.values()){
+            const objectResolvers = objectType.getResolvers();
+            if (objectResolvers) resolvers[objectType.name] = objectResolvers;
+        }
+        return resolvers;
+    }
+    async _executePlugins(methodName, fn) {
+        for (const plugin of this._plugins)if (plugin[methodName]) await fn(plugin);
+    }
+    _executePluginsSync(methodName, fn) {
+        for (const plugin of this._plugins)if (plugin[methodName]) fn(plugin);
+    }
+    _addDefaultScalars() {
+        DefaultScalars.forEach((scalar)=>this.scalar(scalar));
+    }
+    constructor(name = null){
+        this._plugins = [];
+        this._middleware = [];
+        this._subSchemas = [];
+        this._objectTypes = new Map();
+        this._inputObjectTypes = new Map();
+        this._enumTypes = new Map();
+        this._unionTypes = new Map();
+        this._scalarTypes = new Map();
+        this._allowedRoles = new Set();
+        this._deniedRoles = new Set();
+        this._allowedQueryRoles = new Set();
+        this._deniedQueryRoles = new Set();
+        this._allowedMutationRoles = new Set();
+        this._deniedMutationRoles = new Set();
+        this._queryObject = new ObjectTypeBuilder('Query');
+        this._name = name;
+        this._tag = Math.round(1000000 * Math.random());
+        this._addDefaultScalars();
+    }
+}
+class SchemaBuilder extends AbstractSchemaBuilder {
+}
+function schema_schema(name = null) {
+    return new SchemaBuilder(name);
+}
+const ts_schema = schema_schema;
+class CreateInputObjectTypeBuilder extends InputObjectTypeBuilder {
+    exclude(...fieldNames) {
+        fieldNames.forEach((name)=>this._exclude.add(name));
+        return this;
+    }
+    include(...fieldNames) {
+        fieldNames.forEach((name)=>this._include.add(name));
+        return this;
+    }
+    async finalizeInputObjectType(context, info) {
+        await super.finalizeInputObjectType(context, info);
+        const entity = this._entityObjectType instanceof ObjectTypeBuilder ? this._entityObjectType : this._entityObjectType();
+        const entityInfo = entity.info();
+        const existingFieldNames = info.fields.map((field)=>field.name);
+        for (const field of entityInfo.fields){
+            const fieldInfo = field.info();
+            if (!isTypeInput(fieldInfo.type, context.rootSchema) || isFieldId(fieldInfo) || existingFieldNames.indexOf(fieldInfo.name) >= 0) continue;
+            if (this._exclude.has(fieldInfo.name) || this._include.size > 0 && !this._include.has(fieldInfo.name)) continue;
+            const inputField = new InputFieldBuilder(fieldInfo.name, fieldInfo.type);
+            if (fieldInfo.nonNull) inputField.nonNull();
+            if (fieldInfo.list) inputField.list();
+            if (fieldInfo.nonNullList) inputField.nonNullList();
+            this.field(inputField);
+        }
+    }
+    constructor(name, entityType){
+        super(name), this._exclude = new Set(), this._include = new Set();
+        this._entityObjectType = entityType;
+    }
+}
+function createInputObjectType(name, entityType) {
+    return new CreateInputObjectTypeBuilder(name, entityType);
+}
+const external_pluralize_namespaceObject = require("pluralize");
+var external_pluralize_default = /*#__PURE__*/ __webpack_require__.n(external_pluralize_namespaceObject);
+function ucFirst(input) {
+    if (null === input || 0 === input.length) return null;
+    return input.charAt(0).toUpperCase() + input.slice(1);
+}
+function lcFirst(input) {
+    if (null === input || 0 === input.length) return null;
+    return input.charAt(0).toLowerCase() + input.slice(1);
+}
+class CompactNamingStrategy {
+    entityObject(schemaName) {
+        return ucFirst(schemaName);
+    }
+    allField(schemaName) {
+        return external_pluralize_default()(lcFirst(schemaName));
+    }
+    findField(schemaName) {
+        return lcFirst(schemaName);
+    }
+    createField(schemaName) {
+        return `create${ucFirst(schemaName)}`;
+    }
+    updateField(schemaName) {
+        return `update${ucFirst(schemaName)}`;
+    }
+    deleteField(schemaName) {
+        return `delete${ucFirst(schemaName)}`;
+    }
+    restoreField(schemaName) {
+        return `restore${ucFirst(schemaName)}`;
+    }
+    findFieldIdArgument(schemaName) {
+        return 'id';
+    }
+    deleteFieldIdArgument(schemaName) {
+        return 'id';
+    }
+    restoreFieldIdArgument(schemaName) {
+        return 'id';
+    }
+    createInputObject(schemaName) {
+        return `Create${ucFirst(schemaName)}Input`;
+    }
+    createFieldInputArgument(schemaName) {
+        return 'input';
+    }
+    updateInputObject(schemaName) {
+        return `Update${ucFirst(schemaName)}Input`;
+    }
+    updateFieldInputArgument(schemaName) {
+        return 'input';
+    }
+}
+function compactNamingStrategy() {
+    return new CompactNamingStrategy();
+}
+class UpdateInputObjectTypeBuilder extends InputObjectTypeBuilder {
+    exclude(...fieldNames) {
+        fieldNames.forEach((name)=>this._exclude.add(name));
+        return this;
+    }
+    include(...fieldNames) {
+        fieldNames.forEach((name)=>this._include.add(name));
+        return this;
+    }
+    async finalizeInputObjectType(context, info) {
+        await super.finalizeInputObjectType(context, info);
+        const entity = this._entityObjectType instanceof ObjectTypeBuilder ? this._entityObjectType : this._entityObjectType();
+        const entityInfo = entity.info();
+        const existingFieldNames = info.fields.map((field)=>field.name);
+        for (const field of entityInfo.fields){
+            const fieldInfo = field.info();
+            if (!isTypeInput(fieldInfo.type, context.rootSchema) || existingFieldNames.indexOf(fieldInfo.name) >= 0) continue;
+            if (this._exclude.has(fieldInfo.name) || this._include.size > 0 && !this._include.has(fieldInfo.name)) continue;
+            const inputField = new InputFieldBuilder(fieldInfo.name, fieldInfo.type);
+            if (isFieldId(fieldInfo)) inputField.nonNull();
+            if (fieldInfo.list) inputField.list();
+            if (fieldInfo.nonNullList) inputField.nonNullList();
+            this.field(inputField);
+        }
+    }
+    constructor(name, entityType){
+        super(name), this._exclude = new Set(), this._include = new Set();
+        this._entityObjectType = entityType;
+    }
+}
+function updateInputObjectType_updateInputObjectType(name, entityType) {
+    return new UpdateInputObjectTypeBuilder(name, entityType);
+}
+var entitySchema_EntityFieldType = /*#__PURE__*/ function(EntityFieldType) {
+    EntityFieldType["ALL"] = "ALL";
+    EntityFieldType["FIND"] = "FIND";
+    EntityFieldType["CREATE"] = "CREATE";
+    EntityFieldType["UPDATE"] = "UPDATE";
+    EntityFieldType["DELETE"] = "DELETE";
+    EntityFieldType["RESTORE"] = "RESTORE";
+    EntityFieldType["RELATION"] = "RELATION";
+    return EntityFieldType;
+}({});
+const entityFieldTypeExtensionName = "$entityFieldType";
+class AbstractEntitySchemaBuilderBase extends AbstractSchemaBuilder {
+    entity(builderOrConfiguratorOrName, configurator = null) {
+        const resolvedArgs = resolveAutoBuilderArgs(builderOrConfiguratorOrName, configurator, ObjectTypeBuilder);
+        const defaultName = ()=>this.namingStrategy.entityObject(this.name);
+        this._entityObjectType = resolveBuilder(resolvedArgs, (name)=>this.createEntityObjectType(name || defaultName));
+        return this;
+    }
+    all(builderOrConfiguratorOrName = null, configurator = null) {
+        const resolvedArgs = resolveAutoBuilderArgs(builderOrConfiguratorOrName, configurator, FieldBuilder);
+        const defaultName = ()=>this.namingStrategy.allField(this.name);
+        this._allField = resolveBuilder(resolvedArgs, (name)=>this.createAllField(name || defaultName));
+        return this;
+    }
+    find(builderOrConfiguratorOrName = null, configurator = null) {
+        const resolvedArgs = resolveAutoBuilderArgs(builderOrConfiguratorOrName, configurator, FieldBuilder);
+        const defaultName = ()=>this.namingStrategy.findField(this.name);
+        this._findField = resolveBuilder(resolvedArgs, (name)=>this.createFindField(name || defaultName));
+        return this;
+    }
+    create(builderOrConfiguratorOrName = null, configurator = null) {
+        const resolvedArgs = resolveAutoBuilderArgs(builderOrConfiguratorOrName, configurator, FieldBuilder);
+        const defaultName = ()=>this.namingStrategy.createField(this.name);
+        this._createField = resolveBuilder(resolvedArgs, (name)=>this.createCreateField(name || defaultName));
+        return this;
+    }
+    update(builderOrConfiguratorOrName = null, configurator = null) {
+        const resolvedArgs = resolveAutoBuilderArgs(builderOrConfiguratorOrName, configurator, FieldBuilder);
+        const defaultName = ()=>this.namingStrategy.updateField(this.name);
+        this._updateField = resolveBuilder(resolvedArgs, (name)=>this.createUpdateField(name || defaultName));
+        return this;
+    }
+    delete(builderOrConfiguratorOrName = null, configurator = null) {
+        const resolvedArgs = resolveAutoBuilderArgs(builderOrConfiguratorOrName, configurator, FieldBuilder);
+        const defaultName = ()=>this.namingStrategy.deleteField(this.name);
+        this._deleteField = resolveBuilder(resolvedArgs, (name)=>this.createDeleteField(name || defaultName));
+        return this;
+    }
+    restore(builderOrConfiguratorOrName = null, configurator = null) {
+        const resolvedArgs = resolveAutoBuilderArgs(builderOrConfiguratorOrName, configurator, FieldBuilder);
+        const defaultName = ()=>this.namingStrategy.restoreField(this.name);
+        this._restoreField = resolveBuilder(resolvedArgs, (name)=>this.createRestoreField(name || defaultName));
+        return this;
+    }
+    allowEntity(...roles) {
+        roles.forEach((role)=>this._allowedEntityRoles.add(role));
+        return this;
+    }
+    denyEntity(...roles) {
+        roles.forEach((role)=>this._deniedEntityRoles.add(role));
+        return this;
+    }
+    entityResolvers(resolvers) {
+        this._entityResolvers = resolvers;
+        return this;
+    }
+    async finalizeSchema() {
+        await super.finalizeSchema();
+        if (!this._entityObjectType) this._entityObjectType = this.createEntityObjectType(this.namingStrategy.entityObject(this.name));
+        this._entityObjectType.allow(...Array.from(this._allowedEntityRoles)).deny(...Array.from(this._deniedEntityRoles));
+        this.object(this._entityObjectType);
+        if (this._allField) {
+            this._allField.type(this._entityObjectType.name);
+            this._allField.extension(entityFieldTypeExtensionName, "ALL");
+            this.query(this._allField);
+        }
+        if (this._findField) {
+            this._findField.type(this._entityObjectType.name);
+            this._findField.extension(entityFieldTypeExtensionName, "FIND");
+            this.query(this._findField);
+        }
+        if (this._createField) {
+            this._createField.type(this._entityObjectType.name);
+            this._createField.extension(entityFieldTypeExtensionName, "CREATE");
+            this.mutation(this._createField);
+        }
+        if (this._updateField) {
+            this._updateField.type(this._entityObjectType.name);
+            this._updateField.extension(entityFieldTypeExtensionName, "UPDATE");
+            this.mutation(this._updateField);
+        }
+        if (this._deleteField) {
+            this._deleteField.extension(entityFieldTypeExtensionName, "DELETE");
+            this.mutation(this._deleteField);
+        }
+        if (this._restoreField) {
+            this._restoreField.type(this._entityObjectType.name);
+            this._restoreField.extension(entityFieldTypeExtensionName, "RESTORE");
+            this.mutation(this._restoreField);
+        }
+        if (this._entityResolvers) this._resolvers = {
+            [this._entityObjectType.name]: ensureInstantiated(this._entityResolvers),
+            ...this._resolvers
+        };
+    }
+    constructor(...args){
+        super(...args), this._allowedEntityRoles = new Set(), this._deniedEntityRoles = new Set();
+    }
+}
+class AbstractEntitySchemaBuilder extends AbstractEntitySchemaBuilderBase {
+    createInput(builderOrConfiguratorOrName = null, configurator = null) {
+        const resolvedArgs = resolveAutoBuilderArgs(builderOrConfiguratorOrName, configurator, FieldBuilder);
+        const defaultName = ()=>this.namingStrategy.createInputObject(this.name);
+        this._createInputObject = resolveBuilder(resolvedArgs, (name)=>this.createCreateInputObject(name || defaultName));
+        return this;
+    }
+    updateInput(builderOrConfiguratorOrName = null, configurator = null) {
+        const resolvedArgs = resolveAutoBuilderArgs(builderOrConfiguratorOrName, configurator, FieldBuilder);
+        const defaultName = ()=>this.namingStrategy.updateInputObject(this.name);
+        this._updateInputObject = resolveBuilder(resolvedArgs, (name)=>this.createUpdateInputObject(name || defaultName));
+        return this;
+    }
+    async finalizeSchema() {
+        await super.finalizeSchema();
+        if (this._findField) this._findField.arg(this.namingStrategy.findFieldIdArgument(this.name), 'ID', (_)=>_.nonNull());
+        if (this._deleteField) this._deleteField.arg(this.namingStrategy.deleteFieldIdArgument(this.name), 'ID', (_)=>_.nonNull());
+        if (this._restoreField) this._restoreField.arg(this.namingStrategy.restoreFieldIdArgument(this.name), 'ID', (_)=>_.nonNull());
+        if (this._createField) {
+            if (!this._createInputObject) this._createInputObject = this.createCreateInputObject(this.namingStrategy.createInputObject(this.name));
+            this._createField.arg(this.namingStrategy.createFieldInputArgument(this.name), this._createInputObject.name, (_)=>_.nonNull());
+        }
+        if (this._createInputObject) this.inputObject(this._createInputObject);
+        if (this._updateField) {
+            if (!this._updateInputObject) this._updateInputObject = this.createUpdateInputObject(this.namingStrategy.updateInputObject(this.name));
+            this._updateField.arg(this.namingStrategy.updateFieldInputArgument(this.name), this._updateInputObject.name, (_)=>_.nonNull());
+        }
+        if (this._updateInputObject) this.inputObject(this._updateInputObject);
+    }
+}
+class EntitySchemaBuilder extends AbstractEntitySchemaBuilder {
+    createEntityObjectType(name) {
+        return new ObjectTypeBuilder(name);
+    }
+    createAllField(name) {
+        return new FieldBuilder(name).list();
+    }
+    createFindField(name) {
+        return new FieldBuilder(name);
+    }
+    createCreateField(name) {
+        return new FieldBuilder(name);
+    }
+    createUpdateField(name) {
+        return new FieldBuilder(name);
+    }
+    createDeleteField(name) {
+        return new FieldBuilder(name, 'Boolean');
+    }
+    createRestoreField(name) {
+        return new FieldBuilder(name);
+    }
+    createCreateInputObject(name) {
+        return new CreateInputObjectTypeBuilder(name, ()=>this._entityObjectType);
+    }
+    createUpdateInputObject(name) {
+        return new UpdateInputObjectTypeBuilder(name, ()=>this._entityObjectType);
+    }
+    constructor(name = null){
+        super(name);
+        this._defaultNamingStrategy = EntitySchemaBuilder.defaultNamingStrategy;
+    }
+}
+EntitySchemaBuilder.defaultNamingStrategy = compactNamingStrategy();
+function entitySchema_entitySchema(name) {
+    return new EntitySchemaBuilder(name);
+}
+class ResolverError extends error_FrameworkError {
+}
+const resolver_ResolverError = ResolverError;
+class ForbiddenError_ForbiddenError extends resolver_ResolverError {
+}
+class InvalidInputError extends resolver_ResolverError {
+}
+class NotFoundError extends resolver_ResolverError {
+}
+class DataError_DataError extends resolver_ResolverError {
+}
+class DescriptiveNamingStrategy {
+    entityObject(schemaName) {
+        return ucFirst(schemaName);
+    }
+    allField(schemaName) {
+        return `all${external_pluralize_default()(ucFirst(schemaName))}`;
+    }
+    findField(schemaName) {
+        return `find${ucFirst(schemaName)}`;
+    }
+    createField(schemaName) {
+        return `create${ucFirst(schemaName)}`;
+    }
+    updateField(schemaName) {
+        return `update${ucFirst(schemaName)}`;
+    }
+    deleteField(schemaName) {
+        return `delete${ucFirst(schemaName)}`;
+    }
+    restoreField(schemaName) {
+        return `restore${ucFirst(schemaName)}`;
+    }
+    findFieldIdArgument(schemaName) {
+        return 'id';
+    }
+    deleteFieldIdArgument(schemaName) {
+        return 'id';
+    }
+    restoreFieldIdArgument(schemaName) {
+        return 'id';
+    }
+    createInputObject(schemaName) {
+        return `Create${ucFirst(schemaName)}Input`;
+    }
+    createFieldInputArgument(schemaName) {
+        return 'input';
+    }
+    updateInputObject(schemaName) {
+        return `Update${ucFirst(schemaName)}Input`;
+    }
+    updateFieldInputArgument(schemaName) {
+        return 'input';
+    }
+}
+function descriptiveNamingStrategy() {
+    return new DescriptiveNamingStrategy();
+}
+const defaultAclMiddlewareOptions = {
+    rolePath: "role",
+    onForbidden: (resource)=>{
+        throw new ForbiddenError_ForbiddenError(`No access to ${resource}`);
+    }
+};
+function honoAclMiddleware(acl, config = null, options = null) {
+    const fullOptions = getOptions(options);
+    return async (c, next)=>{
+        const fullPath = c.req.path;
+        if (!config) config = {
+            resource: fullPath
+        };
+        const role = c.get(fullOptions.rolePath) ?? null;
+        const allowed = acl.validate(config, role);
+        if (!allowed) fullOptions.onForbidden(fullPath);
+        return await next();
+    };
+}
+function graphQLAclMiddleware(acl, schemaName, options = null) {
+    const fullOptions = getOptions(options);
+    return (resolve, root, args, context, info)=>{
+        const pathResource = getPathResource(info.path);
+        const parsedConfig = {
+            resource: `${schemaName}:${pathResource}`
+        };
+        const role = context.get(fullOptions.rolePath) ?? null;
+        const allowed = acl.validate(parsedConfig, role);
+        if (!allowed) fullOptions.onForbidden(pathResource);
+        return resolve(root, args, context, info);
+    };
+}
+function getPathResource(path) {
+    return [
+        path.typename,
+        path.key
+    ].join('.');
+}
+function getOptions(options) {
+    return (0, compat_namespaceObject.defaults)({}, options || {}, defaultAclMiddlewareOptions);
+}
+var acl_AclAction = /*#__PURE__*/ function(AclAction) {
+    AclAction[AclAction["DENY"] = 0] = "DENY";
+    AclAction[AclAction["ALLOW"] = 1] = "ALLOW";
+    return AclAction;
+}({});
+const defaultAclOptions = {
+    defaultAction: 0,
+    learn: true
+};
+class AclPlugin {
+    defaultAction(action) {
+        this._options.defaultAction = action;
+        return this;
+    }
+    learn(learn = true) {
+        this._options.learn = learn;
+        return this;
+    }
+    role(identifier, parent = null) {
+        this._roles.set(identifier, {
+            identifier,
+            parent
+        });
+        return this;
+    }
+    allow(resource, roles) {
+        const parsedRoles = new Set((0, compat_namespaceObject.isArray)(roles) ? roles : [
+            roles
+        ]);
+        if (this._options.learn) this._learnRoles(parsedRoles);
+        if (this._allowRules.has(resource)) {
+            const config = this._allowRules.get(resource);
+            parsedRoles.forEach((role)=>config.roles.add(role));
+        } else this._allowRules.set(resource, this._getRuleConfig(resource, parsedRoles));
+        return this;
+    }
+    deny(resource, roles) {
+        const parsedRoles = new Set((0, compat_namespaceObject.isArray)(roles) ? roles : [
+            roles
+        ]);
+        if (this._options.learn) this._learnRoles(parsedRoles);
+        if (this._denyRules.has(resource)) {
+            const config = this._denyRules.get(resource);
+            parsedRoles.forEach((role)=>config.roles.add(role));
+        } else this._denyRules.set(resource, this._getRuleConfig(resource, parsedRoles));
+        return this;
+    }
+    isAllowed(role, resource) {
+        let determinedAction = this._options.defaultAction;
+        const allowRules = this._findRules(resource, this._allowRules);
+        const denyRules = this._findRules(resource, this._denyRules);
+        const rules = (0, compat_namespaceObject.sortBy)([
+            ...allowRules.map((rule)=>({
+                    rule,
+                    action: 1
+                })),
+            ...denyRules.map((rule)=>({
+                    rule,
+                    action: 0
+                }))
+        ], (rule)=>rule.rule.name.length);
+        for (const { rule, action } of rules)if (this.isRoleIncluded(role, rule.roles)) determinedAction = action;
+        return 1 === determinedAction;
+    }
+    isRoleIncluded(role, compareRoles) {
+        const roleConfig = this._roles.get(role);
+        if (!roleConfig) throw new error_FrameworkError(`Role "${role}" not registered`);
+        if (compareRoles.has(role)) return true;
+        const roleList = this._getRoleList(roleConfig);
+        for (const candidate of compareRoles)if (roleList.indexOf(candidate) >= 0) return true;
+        return false;
+    }
+    validate(config, role = null) {
+        let parsedConfig;
+        if ((0, compat_namespaceObject.isArray)(config)) parsedConfig = {
+            allowedRoles: config
+        };
+        else if ((0, compat_namespaceObject.isString)(config) || (0, compat_namespaceObject.isNumber)(config)) parsedConfig = {
+            allowedRoles: [
+                config
+            ]
+        };
+        else if (config) parsedConfig = config;
+        let allowed = 1 === this._options.defaultAction;
+        if (role) {
+            if (parsedConfig.allowedRoles) allowed = this.isRoleIncluded(role, new Set(parsedConfig.allowedRoles));
+            else if (parsedConfig.resource) allowed = this.isAllowed(role, parsedConfig.resource);
+        }
+        return allowed;
+    }
+    middleware(config = null) {
+        return honoAclMiddleware(this, config, this._options);
+    }
+    rolePath(path) {
+        this._options.rolePath = path;
+        return this;
+    }
+    onForbidden(handler) {
+        this._options.onForbidden = handler;
+        return this;
+    }
+    beforeBuildSchema(builder, rootBuilder) {
+        builder.use(graphQLAclMiddleware(this, rootBuilder.name || rootBuilder.tag.toString(), this._options));
+    }
+    afterBuildSchema(builder, schema, rootBuilder) {
+        const schemaId = rootBuilder.name || rootBuilder.tag.toString();
+        for (const type of builder.getObjectTypes()){
+            const typeInfo = type.info();
+            this.addRules(`${schemaId}:${type.name}.*`, typeInfo.allowedRoles, typeInfo.deniedRoles);
+            for (const field of type.info().fields){
+                const fieldInfo = field.info();
+                this.addRules(`${schemaId}:${type.name}.${field.name}`, fieldInfo.allowedRoles, fieldInfo.deniedRoles);
+            }
+        }
+    }
+    addRules(resource, allowed, denied) {
+        if (allowed.size > 0) this.allow(resource, Array.from(allowed));
+        if (denied.size > 0) this.deny(resource, Array.from(denied));
+    }
+    _findRules(resource, collection) {
+        const allRules = Array.from(collection.values());
+        return allRules.filter((rule)=>{
+            if ((0, compat_namespaceObject.isString)(rule.resource)) return rule.resource === resource;
+            if (rule.resource instanceof RegExp) return rule.resource.test(resource);
+            return false;
+        });
+    }
+    _learnRoles(roles) {
+        for (const role of roles)if (!this._roles.has(role)) this.role(role);
+    }
+    _getRoleList(roleConfig) {
+        if (!roleConfig) return [];
+        if (!roleConfig.parent) return [
+            roleConfig.identifier
+        ];
+        return [
+            roleConfig.identifier,
+            ...this._getRoleList(this._roles.get(roleConfig.parent))
+        ];
+    }
+    _getRuleConfig(name, roles) {
+        let resource = name;
+        if (name.indexOf('*') >= 0) {
+            const pattern = (0, compat_namespaceObject.escapeRegExp)(name).replace('\\*', '(.*)');
+            resource = new RegExp(`^${pattern}$`);
+        }
+        return {
+            name,
+            resource,
+            roles
+        };
+    }
+    constructor(options){
+        this._roles = new Map();
+        this._allowRules = new Map();
+        this._denyRules = new Map();
+        this._options = (0, compat_namespaceObject.defaults)(options || {}, defaultAclMiddlewareOptions, defaultAclOptions);
+    }
+}
+function aclPlugin(options) {
+    return new AclPlugin(options);
+}
+class PluginError_PluginError extends error_FrameworkError {
+}
+const PluginError = PluginError_PluginError;
+const defaultEqualsFilterPluginOptions = {
+    multi: false,
+    manual: false,
+    argumentName: 'filter',
+    inputName: (typeName)=>`${typeName}EqualsFilter`
+};
+class EqualsFilterPlugin {
+    multi(multi = true) {
+        this._options.multi = multi;
+        return this;
+    }
+    manual(manual = true) {
+        this._options.manual = manual;
+        return this;
+    }
+    field(name, type) {
+        if (!this._options.fields) this._options.fields = [];
+        this._options.fields.push({
+            name,
+            type
+        });
+        return this;
+    }
+    exclude(...fieldNames) {
+        fieldNames.forEach((name)=>this._options.exclude.push(name));
+        return this;
+    }
+    include(...fieldNames) {
+        fieldNames.forEach((name)=>this._options.include.push(name));
+        return this;
+    }
+    argumentName(name) {
+        this._options.argumentName = name;
+        return this;
+    }
+    inputName(nameFactory) {
+        this._options.inputName = nameFactory;
+        return this;
+    }
+    beforeBuildField(builder, context, info) {
+        if (!info.list) return;
+        const typeName = info.type.toString();
+        const inputTypeName = this._options.inputName(typeName);
+        let targetObjectType;
+        if (!this._options.manual) {
+            targetObjectType = context.rootSchema.findType(typeName, true);
+            if (!targetObjectType) throw new PluginError(`Filter target object ${typeName} not found`);
+            if (!(targetObjectType instanceof ObjectTypeBuilder)) throw new PluginError(`Filter target ${typeName} is not an object type`);
+        }
+        const inputType = this._createFilterInputType(context, inputTypeName, targetObjectType);
+        context.schema.inputObject(inputType);
+        builder.arg(this._options.argumentName, inputTypeName, (_)=>_.description("Configuration for how the nodes should be filtered"));
+    }
+    _createFilterInputType(context, name, targetObjectType) {
+        const inputObjectType = ts_inputObjectType(name).description("Configuration for how the nodes should be filtered");
+        const fields = new Set();
+        if (targetObjectType) for (const field of targetObjectType.info().fields){
+            var _this__options_include;
+            const fieldInfo = field.info();
+            if (!fieldInfo.list && !!isTypeInput(fieldInfo.type, context.rootSchema)) {
+                if ((null === (_this__options_include = this._options.include) || void 0 === _this__options_include ? !void 0 : !_this__options_include.length) || !!this._options.include.includes(field.name)) fields.add({
+                    name: field.name,
+                    type: fieldInfo.type
+                });
+            }
+        }
+        if (this._options.fields) this._options.fields.forEach((field)=>fields.add(field));
+        const extraFields = this._getExtraFieldConfigs(context, name, targetObjectType);
+        if (extraFields) extraFields.forEach((extraField)=>fields.add(extraField));
+        for (const field of fields)if (!(this._options.exclude && this._options.exclude.indexOf(field.name) >= 0)) inputObjectType.field(field.name, field.type, (_)=>{
+            if (this._options.multi) _.list();
+        });
+        return inputObjectType;
+    }
+    _getExtraFieldConfigs(context, name, targetObjectType) {
+        return null;
+    }
+    constructor(options){
+        this._options = (0, compat_namespaceObject.defaults)(options || {}, defaultEqualsFilterPluginOptions, {
+            exclude: [],
+            include: []
+        });
+    }
+}
+function equalsFilterPlugin(options) {
+    return new EqualsFilterPlugin(options);
+}
+const defaultSearchFilterPluginOptions = {
+    argumentName: 'search'
+};
+class SearchFilterPlugin {
+    beforeBuildField(builder, context, info) {
+        if (!info.list) return;
+        builder.arg(this._options.argumentName, 'String', (_)=>_.description('Search query'));
+    }
+    constructor(options){
+        this._options = (0, compat_namespaceObject.defaults)(options || {}, defaultSearchFilterPluginOptions);
+    }
+}
+function searchFilterPlugin() {
+    return new SearchFilterPlugin();
+}
+const PageInfoObjectTypeName = "PageInfo";
+class ConnectionPaginationPlugin {
+    totalCount(totalCount = true) {
+        this._totalCount = totalCount;
+        return this;
+    }
+    beforeBuildField(builder, context, info) {
+        if (!info.list) return;
+        if (!context.schema.hasType(PageInfoObjectTypeName)) context.schema.object(this._createPageInfoObjectType());
+        const typeName = info.type.toString();
+        const targetType = context.rootSchema.findType(typeName, true);
+        if (!targetType) throw new PluginError(`Edges target type "${typeName}" not found`);
+        if (!(targetType instanceof ObjectTypeBuilder)) throw new PluginError(`Edges target "${typeName}" is not an object type`);
+        const targetObjectInfo = targetType.info();
+        const pageInfoType = context.schema.findType(PageInfoObjectTypeName);
+        pageInfoType.allow(...Array.from(targetObjectInfo.allowedRoles));
+        pageInfoType.deny(...Array.from(targetObjectInfo.deniedRoles));
+        const edgeObjectTypeName = `${typeName}Edge`;
+        const edgeObjectType = this._createEdgeObjectType(edgeObjectTypeName, typeName);
+        edgeObjectType.allow(...Array.from(targetObjectInfo.allowedRoles));
+        edgeObjectType.deny(...Array.from(targetObjectInfo.deniedRoles));
+        context.schema.object(edgeObjectType);
+        const connectionObjectTypeName = `${typeName}Connection`;
+        const connectionObjectType = this._createConnectionObjectType(connectionObjectTypeName, edgeObjectTypeName);
+        connectionObjectType.allow(...Array.from(targetObjectInfo.allowedRoles));
+        connectionObjectType.deny(...Array.from(targetObjectInfo.deniedRoles));
+        context.schema.object(connectionObjectType);
+        builder.type(connectionObjectTypeName).list(false);
+    }
+    _createPageInfoObjectType() {
+        return ts_objectType(PageInfoObjectTypeName).description('Provides information about the paging state').field('hasNextPage', 'Boolean', (_)=>_.nonNull().description('Indicates whether there is a next page')).field('hasPreviousPage', 'Boolean', (_)=>_.nonNull().description('Indicates whether there is a previous page')).field('startCursor', 'String', (_)=>_.description('Cursor for the first node')).field('endCursor', 'String', (_)=>_.description('Cursor for the last node'));
+    }
+    _createConnectionObjectType(name, edgeTypeName) {
+        const type = ts_objectType(name).description(`Connection with ${edgeTypeName}`).field('pageInfo', PageInfoObjectTypeName, (_)=>_.nonNull().description('Provides information about the paging state')).field('edges', edgeTypeName, (_)=>_.list().description('List of the queried edges'));
+        if (this._totalCount) type.field('totalCount', 'Int', (_)=>_.nonNull().description('Total number of nodes'));
+        return type;
+    }
+    _createEdgeObjectType(name, typeName) {
+        return ts_objectType(name).description(`${typeName} edge`).field('node', typeName, (_)=>_.description('Current node')).field('cursor', 'String', (_)=>_.nonNull().description('Cursor for the current node'));
+    }
+    constructor(){
+        this._totalCount = false;
+    }
+}
+function connectionPaginationPlugin() {
+    return new ConnectionPaginationPlugin();
+}
+class FirstAfterPaginationPlugin {
+    beforeBuildField(builder, context, info) {
+        if (!info.list) return;
+        builder.arg('first', 'Int', (_)=>_.description('Number of nodes to return')).arg('after', 'String', (_)=>_.description('Cursor for item after which results are to be selected'));
+    }
+}
+function firstAfterPaginationPlugin() {
+    return new FirstAfterPaginationPlugin();
+}
+class ItemsPaginationPlugin {
+    beforeBuildField(builder, context, info) {
+        if (!info.list) return;
+        const typeName = info.type.toString();
+        const targetType = context.rootSchema.findType(typeName, true);
+        if (!targetType) throw new PluginError(`Items target type "${typeName}" not found`);
+        if (!(targetType instanceof ObjectTypeBuilder)) throw new PluginError(`Items target "${typeName}" is not an object type`);
+        const targetObjectInfo = targetType.info();
+        const listObjectTypeName = `${typeName}List`;
+        const listObjectType = this._createListObjectType(listObjectTypeName, typeName);
+        listObjectType.allow(...Array.from(targetObjectInfo.allowedRoles));
+        listObjectType.deny(...Array.from(targetObjectInfo.deniedRoles));
+        context.schema.object(listObjectType);
+        builder.type(listObjectTypeName).list(false);
+    }
+    _createListObjectType(name, typeName) {
+        return ts_objectType(name).description(`Collection of ${typeName} nodes`).field('items', typeName, (_)=>_.list().nonNull().description('List of the queried nodes')).field('totalCount', 'Int', (_)=>_.nonNull().description('Total number of nodes'));
+    }
+}
+function itemsPaginationPlugin() {
+    return new ItemsPaginationPlugin();
+}
+class OffsetLimitPaginationPlugin {
+    beforeBuildField(builder, context, info) {
+        if (!info.list) return;
+        builder.arg('offset', 'Int', (_)=>_.description('Offset for the nodes to return')).arg('limit', 'Int', (_)=>_.description('Number of nodes to return'));
+    }
+}
+function offsetLimitPaginationPlugin() {
+    return new OffsetLimitPaginationPlugin();
+}
+class MultiPlugin {
+    getPlugins() {
+        return [];
+    }
+    async execute(methodName, fn) {
+        const results = [];
+        for (const plugin of this._plugins)if (plugin[methodName]) {
+            const result = await fn(plugin);
+            results.push(result);
+        }
+        return results;
+    }
+    executeSync(methodName, fn) {
+        const results = [];
+        for (const plugin of this._plugins)if (plugin[methodName]) {
+            const result = fn(plugin);
+            results.push(result);
+        }
+        return results;
+    }
+    async beforeFinalizeSchema(builder) {
+        await this.execute('beforeFinalizeSchema', (plugin)=>plugin.beforeFinalizeSchema(builder));
+    }
+    async afterFinalizeSchema(builder) {
+        await this.execute('afterFinalizeSchema', (plugin)=>plugin.afterFinalizeSchema(builder));
+    }
+    async beforeFinalizeObjectType(builder, context, info) {
+        await this.execute('beforeFinalizeObjectType', (plugin)=>plugin.beforeFinalizeObjectType(builder, context, info));
+    }
+    async afterFinalizeObjectType(builder, context, info) {
+        await this.execute('afterFinalizeObjectType', (plugin)=>plugin.afterFinalizeObjectType(builder, context, info));
+    }
+    async beforeFinalizeInputObjectType(builder, context, info) {
+        await this.execute('beforeFinalizeInputObjectType', (plugin)=>plugin.beforeFinalizeInputObjectType(builder, context, info));
+    }
+    async afterFinalizeInputObjectType(builder, context, info) {
+        await this.execute('afterFinalizeInputObjectType', (plugin)=>plugin.afterFinalizeInputObjectType(builder, context, info));
+    }
+    async beforeFinalizeEnumType(builder, context, info) {
+        await this.execute('beforeFinalizeEnumType', (plugin)=>plugin.beforeFinalizeEnumType(builder, context, info));
+    }
+    async afterFinalizeEnumType(builder, context, info) {
+        await this.execute('afterFinalizeEnumType', (plugin)=>plugin.afterFinalizeEnumType(builder, context, info));
+    }
+    async beforeFinalizeEnumValue(builder, context, info) {
+        await this.execute('beforeFinalizeEnumValue', (plugin)=>plugin.beforeFinalizeEnumValue(builder, context, info));
+    }
+    async afterFinalizeEnumValue(builder, context, info) {
+        await this.execute('afterFinalizeEnumValue', (plugin)=>plugin.afterFinalizeEnumValue(builder, context, info));
+    }
+    async beforeFinalizeUnionType(builder, context, info) {
+        await this.execute('beforeFinalizeUnionType', (plugin)=>plugin.beforeFinalizeUnionType(builder, context, info));
+    }
+    async afterFinalizeUnionType(builder, context, info) {
+        await this.execute('afterFinalizeUnionType', (plugin)=>plugin.afterFinalizeUnionType(builder, context, info));
+    }
+    async beforeFinalizeField(builder, context, info) {
+        await this.execute('beforeFinalizeField', (plugin)=>plugin.beforeFinalizeField(builder, context, info));
+    }
+    async afterFinalizeField(builder, context, info) {
+        await this.execute('afterFinalizeField', (plugin)=>plugin.afterFinalizeField(builder, context, info));
+    }
+    async beforeFinalizeInputField(builder, context, info) {
+        await this.execute('beforeFinalizeInputField', (plugin)=>plugin.beforeFinalizeInputField(builder, context, info));
+    }
+    async afterFinalizeInputField(builder, context, info) {
+        await this.execute('afterFinalizeInputField', (plugin)=>plugin.afterFinalizeInputField(builder, context, info));
+    }
+    async beforeFinalizeArgument(builder, context, info) {
+        await this.execute('beforeFinalizeArgument', (plugin)=>plugin.beforeFinalizeArgument(builder, context, info));
+    }
+    async afterFinalizeArgument(builder, context, info) {
+        await this.execute('afterFinalizeArgument', (plugin)=>plugin.afterFinalizeArgument(builder, context, info));
+    }
+    beforeBuild(rootBuilder) {
+        this.executeSync('beforeBuild', (plugin)=>plugin.beforeBuild(rootBuilder));
+    }
+    afterBuild(rootBuilder, schema) {
+        this.executeSync('afterBuild', (plugin)=>plugin.afterBuild(rootBuilder, schema));
+    }
+    beforeBuildSchema(builder, rootBuilder) {
+        this.executeSync('beforeBuildSchema', (plugin)=>plugin.beforeBuildSchema(builder, rootBuilder));
+    }
+    afterBuildSchema(builder, schema, rootBuilder) {
+        this.executeSync('afterBuildSchema', (plugin)=>plugin.afterBuildSchema(builder, schema, rootBuilder));
+    }
+    beforeBuildObjectType(builder, context, info) {
+        this.executeSync('beforeBuildObjectType', (plugin)=>plugin.beforeBuildObjectType(builder, context, info));
+    }
+    afterBuildObjectType(builder, context, info, objectType) {
+        this.executeSync('afterBuildObjectType', (plugin)=>plugin.afterBuildObjectType(builder, context, info, objectType));
+    }
+    beforeBuildInputObjectType(builder, context, info) {
+        this.executeSync('beforeBuildInputObjectType', (plugin)=>plugin.beforeBuildInputObjectType(builder, context, info));
+    }
+    afterBuildInputObjectType(builder, context, info, inputObjectType) {
+        this.executeSync('afterBuildInputObjectType', (plugin)=>plugin.afterBuildInputObjectType(builder, context, info, inputObjectType));
+    }
+    beforeBuildEnumType(builder, context, info) {
+        this.executeSync('beforeBuildEnumType', (plugin)=>plugin.beforeBuildEnumType(builder, context, info));
+    }
+    afterBuildEnumType(builder, context, info, enumType) {
+        this.executeSync('afterBuildEnumType', (plugin)=>plugin.afterBuildEnumType(builder, context, info, enumType));
+    }
+    beforeBuildEnumValue(builder, context, info) {
+        this.executeSync('beforeBuildEnumValue', (plugin)=>plugin.beforeBuildEnumValue(builder, context, info));
+    }
+    afterBuildEnumValue(builder, context, info, enumValue) {
+        this.executeSync('afterBuildEnumValue', (plugin)=>plugin.afterBuildEnumValue(builder, context, info, enumValue));
+    }
+    beforeBuildUnionType(builder, context, info) {
+        this.executeSync('beforeBuildUnionType', (plugin)=>plugin.beforeBuildUnionType(builder, context, info));
+    }
+    afterBuildUnionType(builder, context, info, unionType) {
+        this.executeSync('afterBuildUnionType', (plugin)=>plugin.afterBuildUnionType(builder, context, info, unionType));
+    }
+    beforeBuildField(builder, context, info) {
+        this.executeSync('beforeBuildField', (plugin)=>plugin.beforeBuildField(builder, context, info));
+    }
+    afterBuildField(builder, context, info, field) {
+        this.executeSync('afterBuildField', (plugin)=>plugin.afterBuildField(builder, context, info, field));
+    }
+    beforeBuildInputField(builder, context, info) {
+        this.executeSync('beforeBuildInputField', (plugin)=>plugin.beforeBuildInputField(builder, context, info));
+    }
+    afterBuildInputField(builder, context, info, inputField) {
+        this.executeSync('afterBuildInputField', (plugin)=>plugin.afterBuildInputField(builder, context, info, inputField));
+    }
+    beforeBuildArgument(builder, context, info) {
+        this.executeSync('beforeBuildArgument', (plugin)=>plugin.beforeBuildArgument(builder, context, info));
+    }
+    afterBuildArgument(builder, context, info, argument) {
+        this.executeSync('afterBuildArgument', (plugin)=>plugin.afterBuildArgument(builder, context, info, argument));
+    }
+    constructor(plugins = null){
+        this._plugins = plugins || this.getPlugins();
+    }
+}
+const plugin_MultiPlugin = MultiPlugin;
+class RelayPaginationPlugin extends plugin_MultiPlugin {
+    getPlugins() {
+        this._firstAfterPlugin = new FirstAfterPaginationPlugin();
+        this._connectionPlugin = new ConnectionPaginationPlugin();
+        return [
+            this._firstAfterPlugin,
+            this._connectionPlugin
+        ];
+    }
+    totalCount(totalCount = true) {
+        this._connectionPlugin.totalCount(totalCount);
+        return this;
+    }
+}
+function relayPaginationPlugin() {
+    return new RelayPaginationPlugin();
+}
+class SimplePaginationPlugin extends plugin_MultiPlugin {
+    getPlugins() {
+        return [
+            new OffsetLimitPaginationPlugin(),
+            new ItemsPaginationPlugin()
+        ];
+    }
+}
+function simplePaginationPlugin() {
+    return new SimplePaginationPlugin();
+}
+var sort_SortDirection = /*#__PURE__*/ function(SortDirection) {
+    SortDirection["ASC"] = "ASC";
+    SortDirection["DESC"] = "DESC";
+    return SortDirection;
+}({});
+const defaultSortPluginOptions = {
+    multi: false,
+    directionEnumName: 'SortDirection',
+    argumentName: 'sort',
+    inputName: (typeName)=>`${typeName}SortConfiguration`,
+    fieldEnumName: (typeName)=>`${typeName}SortField`
+};
+class SortPlugin {
+    multi(multi = true) {
+        this._options.multi = multi;
+        return this;
+    }
+    field(...fieldNames) {
+        if (!this._options.fields) this._options.fields = [];
+        fieldNames.forEach((name)=>this._options.fields.push(name));
+        return this;
+    }
+    exclude(...fieldNames) {
+        fieldNames.forEach((name)=>this._options.exclude.push(name));
+        return this;
+    }
+    include(...fieldNames) {
+        fieldNames.forEach((name)=>this._options.include.push(name));
+        return this;
+    }
+    directionEnumName(name) {
+        this._options.directionEnumName = name;
+        return this;
+    }
+    argumentName(name) {
+        this._options.argumentName = name;
+        return this;
+    }
+    inputName(nameFactory) {
+        this._options.inputName = nameFactory;
+        return this;
+    }
+    fieldEnumName(nameFactory) {
+        this._options.fieldEnumName = nameFactory;
+        return this;
+    }
+    beforeBuildField(builder, context, info) {
+        if (!info.list) return;
+        if (!context.schema.hasType(this._options.directionEnumName)) context.schema.enum(this._createSortDirectionEnum());
+        const typeName = info.type.toString();
+        const inputTypeName = this._options.inputName(typeName);
+        const fieldEnumName = this._options.fieldEnumName(typeName);
+        let targetObjectType;
+        if (!this._options.fields) {
+            targetObjectType = context.rootSchema.findType(typeName, true);
+            if (!targetObjectType) throw new PluginError(`Sort target object "${typeName}" not found`);
+            if (!(targetObjectType instanceof ObjectTypeBuilder)) throw new PluginError(`Sort target "${typeName}" is not an object type`);
+        }
+        const enumType = this._createSortFieldEnum(context, fieldEnumName, typeName, targetObjectType);
+        context.schema.enum(enumType);
+        const inputType = this._createSortInputType(inputTypeName, fieldEnumName);
+        context.schema.inputObject(inputType);
+        builder.arg(this._options.argumentName, inputTypeName, (_)=>{
+            if (this._options.multi) _.list().description('Collection of sort configurations');
+            else _.description('Sort configuration');
+        });
+    }
+    _createSortInputType(name, enumName) {
+        return ts_inputObjectType(name).description("Configuration for how the nodes should be sorted").field('field', enumName, (_)=>_.nonNull().description('Field to sort on')).field('direction', this._options.directionEnumName, (_)=>_.nonNull().description('Direction to sort'));
+    }
+    _createSortFieldEnum(context, name, typeName, targetObjectType) {
+        const enumBuilder = ts_enumType(name).description(`Field to sort ${typeName} on`);
+        const fields = new Set();
+        if (targetObjectType) for (const field of targetObjectType.info().fields){
+            const fieldInfo = field.info();
+            if (!fieldInfo.list && isTypeInput(fieldInfo.type, context.rootSchema)) fields.add(field.name);
+        }
+        else if (this._options.fields) this._options.fields.forEach((field)=>fields.add(field));
+        if (this._options.include) this._options.include.forEach((field)=>fields.add(field));
+        const extraValues = this._getExtraEnumValues(context, name, typeName, targetObjectType);
+        if (extraValues) extraValues.forEach((extraField)=>fields.add(extraField));
+        for (const field of fields)if (!(this._options.exclude && this._options.exclude.indexOf(field) >= 0)) enumBuilder.value(field, field);
+        return enumBuilder;
+    }
+    _createSortDirectionEnum() {
+        return ts_enumType(this._options.directionEnumName).description('Direction to sort').value("ASC", "ASC", (_)=>_.description('Sort ascending')).value("DESC", "DESC", (_)=>_.description('Sort descending'));
+    }
+    _getExtraEnumValues(context, name, typeName, targetObjectType) {
+        return null;
+    }
+    constructor(options){
+        this._options = (0, compat_namespaceObject.defaults)(options || {}, defaultSortPluginOptions, {
+            exclude: [],
+            include: []
+        });
+    }
+}
+function sortPlugin(options) {
+    return new SortPlugin(options);
+}
+const ts_rslib_entry_ = ts_schema;
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});