@strapi/plugin-graphql 4.15.5 → 4.16.0

package/dist/server/services/extension/extension.d.ts

@@ -0,0 +1,63 @@
+import * as nexus from 'nexus';
+import type { Strapi } from '@strapi/types';
+import type * as Nexus from 'nexus';
+export type Configuration = {
+    types?: NexusGen[];
+    typeDefs?: string;
+    resolvers?: object;
+    resolversConfig?: object;
+    plugins?: Nexus.PluginConfig[];
+};
+export type ConfigurationFactory = (options: {
+    strapi: Strapi;
+    nexus: typeof nexus;
+    typeRegistry: object;
+}) => Configuration;
+export type Extension = {
+    types: NexusGen[];
+    typeDefs: string[];
+    resolvers: object;
+    resolversConfig: object;
+    plugins: Nexus.PluginConfig[];
+};
+declare const createExtension: ({ strapi }: {
+    strapi: Strapi;
+}) => {
+    shadowCRUD: (uid: string) => {
+        isEnabled(): boolean;
+        isDisabled(): boolean;
+        areQueriesEnabled(): boolean;
+        areQueriesDisabled(): boolean;
+        areMutationsEnabled(): boolean;
+        areMutationsDisabled(): boolean;
+        isActionEnabled(action: string): boolean;
+        isActionDisabled(action: string): boolean;
+        disable(): any;
+        disableQueries(): any;
+        disableMutations(): any;
+        disableAction(action: string): any;
+        disableActions(actions?: never[]): any;
+        field(fieldName: string): {
+            isEnabled(): boolean;
+            hasInputEnabled(): boolean;
+            hasOutputEnabled(): boolean;
+            hasFiltersEnabeld(): boolean;
+            disable(): any;
+            disableOutput(): any;
+            disableInput(): any;
+            disableFilters(): any;
+        };
+    };
+    /**
+     * Register a new extension configuration
+     */
+    use(configuration: Configuration | ConfigurationFactory): any;
+    /**
+     * Convert the registered configuration into a single extension object & return it
+     */
+    generate({ typeRegistry }: {
+        typeRegistry: object;
+    }): Extension;
+};
+export default createExtension;
+//# sourceMappingURL=extension.d.ts.map

package/dist/server/services/extension/extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../../../../server/src/services/extension/extension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAIpC,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,KAAK,CAAC,YAAY,EAAE,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,EAAE;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB,KAAK,aAAa,CAAC;AAEpB,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,KAAK,CAAC,YAAY,EAAE,CAAC;CAC/B,CAAC;AAUF,QAAA,MAAM,eAAe;YAA0B,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;IAMjD;;OAEG;uBACgB,aAAa,GAAG,oBAAoB;IAMvD;;OAEG;;sBACwC,MAAM;;CAwCpD,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/dist/server/services/extension/index.d.ts

@@ -0,0 +1,3 @@
+import createExtension from './extension';
+export default createExtension;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/services/extension/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/services/extension/index.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,aAAa,CAAC;AAE1C,eAAe,eAAe,CAAC"}

package/dist/server/services/extension/shadow-crud-manager.d.ts

@@ -0,0 +1,40 @@
+export type ContentTypeConfig = {
+    enabled: boolean;
+    mutations: boolean;
+    queries: boolean;
+    disabledActions: string[];
+    fields: Map<string, FieldConfig>;
+};
+export type FieldConfig = {
+    enabled: boolean;
+    input: boolean;
+    output: boolean;
+    filters: boolean;
+};
+declare const _default: () => (uid: string) => {
+    isEnabled(): boolean;
+    isDisabled(): boolean;
+    areQueriesEnabled(): boolean;
+    areQueriesDisabled(): boolean;
+    areMutationsEnabled(): boolean;
+    areMutationsDisabled(): boolean;
+    isActionEnabled(action: string): boolean;
+    isActionDisabled(action: string): boolean;
+    disable(): any;
+    disableQueries(): any;
+    disableMutations(): any;
+    disableAction(action: string): any;
+    disableActions(actions?: never[]): any;
+    field(fieldName: string): {
+        isEnabled(): boolean;
+        hasInputEnabled(): boolean;
+        hasOutputEnabled(): boolean;
+        hasFiltersEnabeld(): boolean;
+        disable(): any;
+        disableOutput(): any;
+        disableInput(): any;
+        disableFilters(): any;
+    };
+};
+export default _default;
+//# sourceMappingURL=shadow-crud-manager.d.ts.map

package/dist/server/services/extension/shadow-crud-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-crud-manager.d.ts","sourceRoot":"","sources":["../../../../server/src/services/extension/shadow-crud-manager.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,OAAO,CAAC;IAEjB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IAEjB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,OAAO,CAAC;IAEjB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAEhB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;oCA0Ba,MAAM;;;;;;;4BA8BS,MAAM;6BAQL,MAAM;;;;0BAsBT,MAAM;;qBAgBX,MAAM;;;;;;;;;;;AA/E7B,wBAyIE"}

package/dist/server/services/format/index.d.ts

@@ -0,0 +1,20 @@
+declare const _default: () => {
+    returnTypes: {
+        toEntityResponse(value: unknown, info?: import("./return-types").InfoType): {
+            value: unknown;
+            info: {
+                args: unknown;
+                resourceUID: string | undefined;
+            };
+        };
+        toEntityResponseCollection(nodes: unknown[], info?: import("./return-types").InfoType): {
+            nodes: unknown[];
+            info: {
+                args: unknown;
+                resourceUID: string | undefined;
+            };
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/services/format/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/services/format/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAEA,wBAEG"}

package/dist/server/services/format/return-types.d.ts

@@ -0,0 +1,22 @@
+export type InfoType = {
+    args?: unknown;
+    resourceUID?: string;
+};
+declare const _default: () => {
+    toEntityResponse(value: unknown, info?: InfoType): {
+        value: unknown;
+        info: {
+            args: unknown;
+            resourceUID: string | undefined;
+        };
+    };
+    toEntityResponseCollection(nodes: unknown[], info?: InfoType): {
+        nodes: unknown[];
+        info: {
+            args: unknown;
+            resourceUID: string | undefined;
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=return-types.d.ts.map

package/dist/server/services/format/return-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"return-types.d.ts","sourceRoot":"","sources":["../../../../server/src/services/format/return-types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;;4BAGwB,OAAO,SAAQ,QAAQ;;;;;;;sCAMb,OAAO,EAAE,SAAQ,QAAQ;;;;;;;;AAP7D,wBAYG"}

package/dist/server/services/index.d.ts

@@ -0,0 +1,287 @@
+/// <reference types="lodash" />
+export declare const services: {
+    builders: ({ strapi }: {
+        strapi: import("@strapi/types").Strapi;
+    }) => {
+        new(name: string, registry: import("./type-registry").TypeRegistry): unknown;
+        delete(name: string): void;
+        get(name: string): any;
+        filters: {
+            operators: import("lodash").Dictionary<{
+                fieldName: string;
+                strapiOperator: string;
+                add(t: import("nexus/dist/core").ObjectDefinitionBlock<string>, type: string): void;
+            }>;
+        };
+        utils: {
+            getContentTypeArgs(contentType: import("@strapi/types/dist/types/core/schemas").Any, { multiple }?: {
+                multiple?: boolean | undefined;
+            }): {
+                filters?: undefined;
+                pagination?: undefined;
+                sort?: undefined;
+                id?: undefined;
+            } | {
+                filters: any;
+                pagination: any;
+                sort: any;
+                id?: undefined;
+            } | {
+                id: string;
+                filters?: undefined;
+                pagination?: undefined;
+                sort?: undefined;
+            } | undefined;
+            getUniqueScalarAttributes(attributes: import("@strapi/types/dist/types/core/schemas").Attributes): {
+                [k: string]: import("@strapi/types/dist/types/core/attributes").Any;
+            };
+            scalarAttributesToFiltersMap(attributes: import("@strapi/types/dist/types/core/schemas").Attributes): import("lodash").Dictionary<any>;
+            transformArgs(args: any, { contentType, usePagination, }: {
+                contentType: import("@strapi/types/dist/types/core/schemas").ContentType;
+                usePagination?: boolean | undefined;
+            }): import("lodash").Omit<any, "filters" | "pagination">;
+        };
+    };
+    'content-api': ({ strapi }: {
+        strapi: import("@strapi/types").Strapi;
+    }) => {
+        buildSchema: () => import("graphql").GraphQLSchema;
+    };
+    constants: () => {
+        PAGINATION_TYPE_NAME: string;
+        RESPONSE_COLLECTION_META_TYPE_NAME: string;
+        PUBLICATION_STATE_TYPE_NAME: string;
+        GRAPHQL_SCALARS: readonly ["ID", "Boolean", "Int", "String", "Long", "Float", "JSON", "Date", "Time", "DateTime"];
+        STRAPI_SCALARS: readonly ["boolean", "integer", "string", "richtext", "blocks", "enumeration", "biginteger", "float", "decimal", "json", "date", "time", "datetime", "timestamp", "uid", "email", "password", "text"];
+        GENERIC_MORPH_TYPENAME: string;
+        KINDS: {
+            readonly type: "type";
+            readonly component: "component";
+            readonly dynamicZone: "dynamic-zone";
+            readonly enum: "enum";
+            readonly entity: "entity";
+            readonly entityResponse: "entity-response";
+            readonly entityResponseCollection: "entity-response-collection";
+            readonly relationResponseCollection: "relation-response-collection";
+            readonly query: "query";
+            readonly mutation: "mutation";
+            readonly input: "input";
+            readonly filtersInput: "filters-input";
+            readonly scalar: "scalar";
+            readonly morph: "polymorphic";
+            readonly internal: "internal";
+        };
+        GRAPHQL_SCALAR_OPERATORS: {
+            readonly ID: readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"];
+            readonly Boolean: readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"];
+            readonly String: readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"];
+            readonly Int: readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"];
+            readonly Long: readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"];
+            readonly Float: readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"];
+            readonly Date: readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"];
+            readonly Time: readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"];
+            readonly DateTime: readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"];
+            readonly JSON: readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"];
+        };
+        SCALARS_ASSOCIATIONS: {
+            readonly uid: "String";
+            readonly email: "String";
+            readonly password: "String";
+            readonly text: "String";
+            readonly boolean: "Boolean";
+            readonly integer: "Int";
+            readonly string: "String";
+            readonly enumeration: "String";
+            readonly richtext: "String";
+            readonly blocks: "JSON";
+            readonly biginteger: "Long";
+            readonly float: "Float";
+            readonly decimal: "Float";
+            readonly json: "JSON";
+            readonly date: "Date";
+            readonly time: "Time";
+            readonly datetime: "DateTime";
+            readonly timestamp: "DateTime";
+        };
+        ERROR_CODES: {
+            readonly emptyDynamicZone: "dynamiczone.empty";
+        };
+        ERROR_TYPE_NAME: string;
+    };
+    extension: ({ strapi }: {
+        strapi: import("@strapi/types").Strapi;
+    }) => {
+        shadowCRUD: (uid: string) => {
+            isEnabled(): boolean;
+            isDisabled(): boolean;
+            areQueriesEnabled(): boolean;
+            areQueriesDisabled(): boolean;
+            areMutationsEnabled(): boolean;
+            areMutationsDisabled(): boolean;
+            isActionEnabled(action: string): boolean;
+            isActionDisabled(action: string): boolean;
+            disable(): any;
+            disableQueries(): any;
+            disableMutations(): any;
+            disableAction(action: string): any;
+            disableActions(actions?: never[]): any;
+            field(fieldName: string): {
+                isEnabled(): boolean;
+                hasInputEnabled(): boolean;
+                hasOutputEnabled(): boolean;
+                hasFiltersEnabeld(): boolean;
+                disable(): any;
+                disableOutput(): any;
+                disableInput(): any;
+                disableFilters(): any;
+            };
+        };
+        use(configuration: import("./extension/extension").Configuration | import("./extension/extension").ConfigurationFactory): any;
+        generate({ typeRegistry }: {
+            typeRegistry: object;
+        }): import("./extension/extension").Extension;
+    };
+    format: () => {
+        returnTypes: {
+            toEntityResponse(value: unknown, info?: import("./format/return-types").InfoType): {
+                value: unknown;
+                info: {
+                    args: unknown;
+                    resourceUID: string | undefined;
+                };
+            };
+            toEntityResponseCollection(nodes: unknown[], info?: import("./format/return-types").InfoType): {
+                nodes: unknown[];
+                info: {
+                    args: unknown;
+                    resourceUID: string | undefined;
+                };
+            };
+        };
+    };
+    internals: (context: import("./types").Context) => {
+        args: {
+            SortArg: import("nexus/dist/core").NexusArgDef<any>;
+            PaginationArg: import("nexus/dist/core").NexusArgDef<any>;
+            PublicationStateArg: import("nexus/dist/core").NexusArgDef<any>;
+        };
+        scalars: {
+            JSON: any;
+            DateTime: any;
+            Time: import("nexus/dist/core").AllNexusOutputTypeDefs;
+            Date: any;
+            Long: any;
+            Upload: import("graphql").GraphQLScalarType | import("graphql").GraphQLEnumType | import("graphql").GraphQLInputObjectType | import("graphql").GraphQLList<any> | import("nexus/dist/core").NexusUnionTypeDef<any> | import("nexus/dist/core").NexusObjectTypeDef<any> | import("graphql").GraphQLNonNull<any> | import("nexus/dist/core").NexusListDef<any> | import("nexus/dist/core").NexusNonNullDef<any> | import("nexus/dist/core").NexusNullDef<any> | import("nexus/dist/core").NexusInputObjectTypeDef<any> | import("nexus/dist/core").NexusEnumTypeDef<any> | import("nexus/dist/core").NexusScalarTypeDef<any> | import("nexus/dist/core").NexusInterfaceTypeDef<any>;
+        };
+        buildInternalTypes: () => {
+            [x: number]: {
+                error: import("nexus/dist/core").NexusObjectTypeDef<any>;
+                pagination: {
+                    Pagination: import("nexus/dist/core").NexusObjectTypeDef<any>;
+                };
+                responseCollectionMeta: {
+                    ResponseCollectionMeta: import("nexus/dist/core").NexusObjectTypeDef<any>;
+                };
+                publicationState?: undefined;
+            } | {
+                publicationState: {
+                    PublicationState: import("nexus/dist/core").NexusEnumTypeDef<any>;
+                };
+                error?: undefined;
+                pagination?: undefined;
+                responseCollectionMeta?: undefined;
+            } | {
+                scalars: any;
+                error?: undefined;
+                pagination?: undefined;
+                responseCollectionMeta?: undefined;
+                publicationState?: undefined;
+            };
+        };
+        helpers: {
+            getEnabledScalars: () => (string | readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"] | undefined)[];
+        };
+    };
+    'type-registry': () => {
+        new: () => import("./type-registry").TypeRegistry;
+    };
+    utils: (context: import("./types").Context) => {
+        naming: {
+            getEnumName: (contentType: import("@strapi/types/dist/types/core/schemas").Any, attributeName: string) => string;
+            getTypeName: (contentType: import("@strapi/types/dist/types/core/schemas").Any, { plurality, }?: {
+                plurality?: "singular" | "plural" | undefined;
+            }) => string;
+            getEntityName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getEntityMetaName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getEntityResponseName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getEntityResponseCollectionName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getRelationResponseCollectionName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getComponentName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getComponentNameFromAttribute: (attribute: import("@strapi/types/dist/types/core/attributes").Component<`${string}.${string}`, false>) => string;
+            getDynamicZoneName: (contentType: import("@strapi/types/dist/types/core/schemas").Any, attributeName: string) => string;
+            getDynamicZoneInputName: (contentType: import("@strapi/types/dist/types/core/schemas").Any, attributeName: string) => string;
+            getComponentInputName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getContentTypeInputName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getEntityQueriesTypeName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getEntityMutationsTypeName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getFiltersInputTypeName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getScalarFilterInputTypeName: (scalarType: string) => string;
+            getMorphRelationTypeName: (contentType: import("@strapi/types/dist/types/core/schemas").Any, attributeName: string) => string;
+            buildCustomTypeNameGenerator: (options: {
+                prefix?: string | undefined;
+                suffix?: string | undefined;
+                firstLetterCase?: "upper" | "lower" | undefined;
+                plurality?: "singular" | "plural" | undefined;
+            }) => (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getFindQueryName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getFindOneQueryName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getCreateMutationTypeName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getUpdateMutationTypeName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+            getDeleteMutationTypeName: (contentType: import("@strapi/types/dist/types/core/schemas").Any) => string;
+        };
+        attributes: {
+            isStrapiScalar: (attribute: import("@strapi/types/dist/types/core/attributes").Any) => any;
+            isGraphQLScalar: (attribute: import("@strapi/types/dist/types/core/attributes").Any) => any;
+            isMorphRelation: (attribute: import("@strapi/types/dist/types/core/attributes").Any) => boolean;
+            isMedia: (value: any) => boolean;
+            isRelation: (value: any) => boolean;
+            isEnumeration: (value: any) => boolean;
+            isComponent: (value: any) => boolean;
+            isDynamicZone: (value: any) => boolean;
+        };
+        mappers: {
+            entityToResponseEntity: (entity: {
+                [key: string]: unknown;
+                [key: number]: unknown;
+                [key: symbol]: unknown;
+                id: import("@strapi/types/dist/types/core/entity").ID;
+            }) => {
+                id: import("@strapi/types/dist/types/core/entity").ID;
+                attributes: {
+                    [key: string]: unknown;
+                    [key: number]: unknown;
+                    [key: symbol]: unknown;
+                    id: import("@strapi/types/dist/types/core/entity").ID;
+                };
+            };
+            entitiesToResponseEntities: import("lodash/fp").LodashMap1x1<{
+                [key: string]: unknown;
+                [key: number]: unknown;
+                [key: symbol]: unknown;
+                id: import("@strapi/types/dist/types/core/entity").ID;
+            }, {
+                id: import("@strapi/types/dist/types/core/entity").ID;
+                attributes: {
+                    [key: string]: unknown;
+                    [key: number]: unknown;
+                    [key: symbol]: unknown;
+                    id: import("@strapi/types/dist/types/core/entity").ID;
+                };
+            }>;
+            graphqlScalarToOperators(graphqlScalar: string): boolean;
+            graphQLFiltersToStrapiQuery(filters: any, contentType: import("@strapi/types/dist/types/core/schemas").Any): any;
+            strapiScalarToGraphQLScalar(strapiScalar: string): any;
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/server/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../server/src/services/index.ts"],"names":[],"mappings":";AASA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASpB,CAAC"}

package/dist/server/services/internals/args/index.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '../../types';
+declare const _default: (context: Context) => {
+    SortArg: import("nexus/dist/core").NexusArgDef<any>;
+    PaginationArg: import("nexus/dist/core").NexusArgDef<any>;
+    PublicationStateArg: import("nexus/dist/core").NexusArgDef<any>;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/services/internals/args/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/internals/args/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;kCAElB,OAAO;;;;;AAAhC,wBAIG"}

package/dist/server/services/internals/args/pagination.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("nexus/dist/core").NexusArgDef<any>;
+export default _default;
+//# sourceMappingURL=pagination.d.ts.map

package/dist/server/services/internals/args/pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/internals/args/pagination.ts"],"names":[],"mappings":";AAaA,wBAGG"}

package/dist/server/services/internals/args/publication-state.d.ts

@@ -0,0 +1,4 @@
+import { Context } from '../../types';
+declare const _default: ({ strapi }: Context) => import("nexus/dist/core").NexusArgDef<any>;
+export default _default;
+//# sourceMappingURL=publication-state.d.ts.map

package/dist/server/services/internals/args/publication-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publication-state.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/internals/args/publication-state.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;qCAEV,OAAO;AAAnC,wBAOE"}

package/dist/server/services/internals/args/sort.d.ts

@@ -0,0 +1,3 @@
+declare const SortArg: import("nexus/dist/core").NexusArgDef<any>;
+export default SortArg;
+//# sourceMappingURL=sort.d.ts.map

package/dist/server/services/internals/args/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/internals/args/sort.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,OAAO,4CAGX,CAAC;AAEH,eAAe,OAAO,CAAC"}

package/dist/server/services/internals/helpers/get-enabled-scalars.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '../../types';
+declare const _default: ({ strapi }: Context) => () => (string | readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"] | undefined)[];
+export default _default;
+//# sourceMappingURL=get-enabled-scalars.d.ts.map

package/dist/server/services/internals/helpers/get-enabled-scalars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-enabled-scalars.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/internals/helpers/get-enabled-scalars.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;qCAGf,OAAO;AAAnC,wBAWI"}

package/dist/server/services/internals/helpers/index.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '../../types';
+declare const _default: (context: Context) => {
+    getEnabledScalars: () => (string | readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"] | undefined)[];
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/services/internals/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/internals/helpers/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;kCAElB,OAAO;;;AAAhC,wBAEG"}

package/dist/server/services/internals/index.d.ts

@@ -0,0 +1,46 @@
+import type { Context } from '../types';
+declare const _default: (context: Context) => {
+    args: {
+        SortArg: import("nexus/dist/core").NexusArgDef<any>;
+        PaginationArg: import("nexus/dist/core").NexusArgDef<any>;
+        PublicationStateArg: import("nexus/dist/core").NexusArgDef<any>;
+    };
+    scalars: {
+        JSON: any;
+        DateTime: any;
+        Time: import("nexus/dist/core").AllNexusOutputTypeDefs;
+        Date: any;
+        Long: any;
+        Upload: import("graphql").GraphQLScalarType | import("graphql").GraphQLEnumType | import("graphql").GraphQLInputObjectType | import("graphql").GraphQLList<any> | import("nexus/dist/core").NexusUnionTypeDef<any> | import("nexus/dist/core").NexusObjectTypeDef<any> | import("graphql").GraphQLNonNull<any> | import("nexus/dist/core").NexusListDef<any> | import("nexus/dist/core").NexusNonNullDef<any> | import("nexus/dist/core").NexusNullDef<any> | import("nexus/dist/core").NexusInputObjectTypeDef<any> | import("nexus/dist/core").NexusEnumTypeDef<any> | import("nexus/dist/core").NexusScalarTypeDef<any> | import("nexus/dist/core").NexusInterfaceTypeDef<any>;
+    };
+    buildInternalTypes: () => {
+        [x: number]: {
+            error: import("nexus/dist/core").NexusObjectTypeDef<any>;
+            pagination: {
+                Pagination: import("nexus/dist/core").NexusObjectTypeDef<any>;
+            };
+            responseCollectionMeta: {
+                ResponseCollectionMeta: import("nexus/dist/core").NexusObjectTypeDef<any>;
+            };
+            publicationState?: undefined;
+        } | {
+            publicationState: {
+                PublicationState: import("nexus/dist/core").NexusEnumTypeDef<any>;
+            };
+            error?: undefined;
+            pagination?: undefined;
+            responseCollectionMeta?: undefined;
+        } | {
+            scalars: any;
+            error?: undefined;
+            pagination?: undefined;
+            responseCollectionMeta?: undefined;
+            publicationState?: undefined;
+        };
+    };
+    helpers: {
+        getEnabledScalars: () => (string | readonly ["and", "or", "not", "eq", "eqi", "ne", "nei", "startsWith", "endsWith", "contains", "notContains", "containsi", "notContainsi", "gt", "gte", "lt", "lte", "null", "notNull", "in", "notIn", "between"] | undefined)[];
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/services/internals/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/services/internals/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;kCAEf,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAhC,wBAKG"}

package/dist/server/services/internals/scalars/date.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLDate } from 'graphql-scalars';
+export default GraphQLDate;
+//# sourceMappingURL=date.d.ts.map

package/dist/server/services/internals/scalars/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/internals/scalars/date.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAmB9C,eAAe,WAAW,CAAC"}

package/dist/server/services/internals/scalars/index.d.ts

@@ -0,0 +1,10 @@
+declare const _default: () => {
+    JSON: any;
+    DateTime: any;
+    Time: import("nexus/dist/core").AllNexusOutputTypeDefs;
+    Date: any;
+    Long: any;
+    Upload: import("graphql").GraphQLScalarType | import("graphql").GraphQLEnumType | import("graphql").GraphQLInputObjectType | import("graphql").GraphQLList<any> | import("nexus/dist/core").NexusUnionTypeDef<any> | import("nexus/dist/core").NexusObjectTypeDef<any> | import("graphql").GraphQLNonNull<any> | import("nexus/dist/core").NexusListDef<any> | import("nexus/dist/core").NexusNonNullDef<any> | import("nexus/dist/core").NexusNullDef<any> | import("nexus/dist/core").NexusInputObjectTypeDef<any> | import("nexus/dist/core").NexusEnumTypeDef<any> | import("nexus/dist/core").NexusScalarTypeDef<any> | import("nexus/dist/core").NexusInterfaceTypeDef<any>;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/services/internals/scalars/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/internals/scalars/index.ts"],"names":[],"mappings":";;;;;;;;AAQA,wBAOG"}

package/dist/server/services/internals/scalars/time.d.ts

@@ -0,0 +1,8 @@
+import { GraphQLScalarType } from 'graphql';
+/**
+ * A GraphQL scalar used to store Time (HH:mm:ss.SSS) values
+ * @type {GraphQLScalarType}
+ */
+declare const TimeScalar: GraphQLScalarType;
+export default TimeScalar;
+//# sourceMappingURL=time.d.ts.map

package/dist/server/services/internals/scalars/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../../../../server/src/services/internals/scalars/time.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAQ,MAAM,SAAS,CAAC;AAKlD;;;GAGG;AACH,QAAA,MAAM,UAAU,mBAsBd,CAAC;AAEH,eAAe,UAAU,CAAC"}

package/dist/server/services/internals/types/error.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '../../types';
+/**
+ * Build an Error object type
+ * @return {Object<string, NexusObjectTypeDef>}
+ */
+declare const _default: ({ strapi }: Context) => import("nexus/dist/core").NexusObjectTypeDef<any>;
+export default _default;
+//# sourceMappingURL=error.d.ts.map