gatsby 2.32.2 → 2.32.3

package/dist/schema/context.d.ts

@@ -1,13 +1,13 @@
-import { GraphQLSchema } from "graphql";
-import { SchemaComposer } from "graphql-compose";
-import { IGraphQLRunnerStats } from "../query/types";
-import { IGatsbyResolverContext, IGraphQLSpanTracer } from "./type-definitions";
-export default function withResolverContext<TSource, TArgs>({ schema, schemaComposer, context, customContext, nodeModel, stats, tracer, }: {
-    schema: GraphQLSchema;
-    schemaComposer: SchemaComposer<IGatsbyResolverContext<TSource, TArgs>> | null;
-    context?: Record<string, any>;
-    customContext?: Record<string, any>;
-    nodeModel?: any;
-    stats?: IGraphQLRunnerStats | null;
-    tracer?: IGraphQLSpanTracer;
-}): IGatsbyResolverContext<TSource, TArgs>;
+import { GraphQLSchema } from "graphql";
+import { SchemaComposer } from "graphql-compose";
+import { IGraphQLRunnerStats } from "../query/types";
+import { IGatsbyResolverContext, IGraphQLSpanTracer } from "./type-definitions";
+export default function withResolverContext<TSource, TArgs>({ schema, schemaComposer, context, customContext, nodeModel, stats, tracer, }: {
+    schema: GraphQLSchema;
+    schemaComposer: SchemaComposer<IGatsbyResolverContext<TSource, TArgs>> | null;
+    context?: Record<string, any>;
+    customContext?: Record<string, any>;
+    nodeModel?: any;
+    stats?: IGraphQLRunnerStats | null;
+    tracer?: IGraphQLSpanTracer;
+}): IGatsbyResolverContext<TSource, TArgs>;

package/dist/schema/infer/inference-metadata.d.ts

@@ -1,72 +1,72 @@
-import { Node } from "../../../index";
-import { TypeConflictReporter } from "./type-conflict-reporter";
-export interface ITypeInfo {
-    first?: string;
-    total: number;
-    example?: unknown;
-}
-export interface ITypeInfoString extends ITypeInfo {
-    empty: number;
-    example: string;
-}
-export interface ITypeInfoDate extends ITypeInfo {
-    example: string;
-}
-export interface ITypeInfoNumber extends ITypeInfo {
-    example: number;
-}
-export interface ITypeInfoBoolean extends ITypeInfo {
-    example: boolean;
-}
-export interface ITypeInfoArray extends ITypeInfo {
-    item: IValueDescriptor;
-}
-export interface ITypeInfoRelatedNodes extends ITypeInfo {
-    nodes: {
-        [key: string]: number;
-    };
-}
-export interface ITypeInfoObject extends ITypeInfo {
-    dprops: {
-        [name: string]: IValueDescriptor;
-    };
-}
-export interface IValueDescriptor {
-    int?: ITypeInfoNumber;
-    float?: ITypeInfoNumber;
-    date?: ITypeInfoDate;
-    string?: ITypeInfoString;
-    boolean?: ITypeInfoBoolean;
-    array?: ITypeInfoArray;
-    relatedNode?: ITypeInfoRelatedNodes;
-    relatedNodeList?: ITypeInfoRelatedNodes;
-    object?: ITypeInfoObject;
-}
-export declare type ValueType = keyof IValueDescriptor;
-export interface ITypeMetadata {
-    typeName?: string;
-    disabled?: boolean;
-    ignored?: boolean;
-    dirty?: boolean;
-    total?: number;
-    ignoredFields?: Set<string>;
-    fieldMap?: Record<string, IValueDescriptor>;
-    typeConflictReporter?: TypeConflictReporter;
-    [key: string]: unknown;
-}
-declare const ignore: (metadata?: ITypeMetadata, set?: boolean) => ITypeMetadata;
-declare const disable: (metadata?: ITypeMetadata, set?: boolean) => ITypeMetadata;
-declare const addNode: (metadata: ITypeMetadata, node: Node) => ITypeMetadata;
-declare const deleteNode: (metadata: ITypeMetadata, node: Node) => ITypeMetadata;
-declare const addNodes: (metadata: ITypeMetadata | undefined, nodes: Array<Node>) => ITypeMetadata;
-declare const isEmpty: ({ fieldMap }: {
-    fieldMap: any;
-}) => boolean;
-declare const hasNodes: (typeMetadata: ITypeMetadata) => boolean;
-declare const haveEqualFields: ({ fieldMap }?: {
-    fieldMap?: {} | undefined;
-}, { fieldMap: otherFieldMap }?: {
-    fieldMap?: {} | undefined;
-}) => boolean;
-declare const initialMetadata: (state?: object | undefined) => ITypeMetadata;
-export { addNode, addNodes, deleteNode, ignore, disable, isEmpty, hasNodes, haveEqualFields, initialMetadata, };
+import { Node } from "../../../index";
+import { TypeConflictReporter } from "./type-conflict-reporter";
+export interface ITypeInfo {
+    first?: string;
+    total: number;
+    example?: unknown;
+}
+export interface ITypeInfoString extends ITypeInfo {
+    empty: number;
+    example: string;
+}
+export interface ITypeInfoDate extends ITypeInfo {
+    example: string;
+}
+export interface ITypeInfoNumber extends ITypeInfo {
+    example: number;
+}
+export interface ITypeInfoBoolean extends ITypeInfo {
+    example: boolean;
+}
+export interface ITypeInfoArray extends ITypeInfo {
+    item: IValueDescriptor;
+}
+export interface ITypeInfoRelatedNodes extends ITypeInfo {
+    nodes: {
+        [key: string]: number;
+    };
+}
+export interface ITypeInfoObject extends ITypeInfo {
+    dprops: {
+        [name: string]: IValueDescriptor;
+    };
+}
+export interface IValueDescriptor {
+    int?: ITypeInfoNumber;
+    float?: ITypeInfoNumber;
+    date?: ITypeInfoDate;
+    string?: ITypeInfoString;
+    boolean?: ITypeInfoBoolean;
+    array?: ITypeInfoArray;
+    relatedNode?: ITypeInfoRelatedNodes;
+    relatedNodeList?: ITypeInfoRelatedNodes;
+    object?: ITypeInfoObject;
+}
+export declare type ValueType = keyof IValueDescriptor;
+export interface ITypeMetadata {
+    typeName?: string;
+    disabled?: boolean;
+    ignored?: boolean;
+    dirty?: boolean;
+    total?: number;
+    ignoredFields?: Set<string>;
+    fieldMap?: Record<string, IValueDescriptor>;
+    typeConflictReporter?: TypeConflictReporter;
+    [key: string]: unknown;
+}
+declare const ignore: (metadata?: ITypeMetadata, set?: boolean) => ITypeMetadata;
+declare const disable: (metadata?: ITypeMetadata, set?: boolean) => ITypeMetadata;
+declare const addNode: (metadata: ITypeMetadata, node: Node) => ITypeMetadata;
+declare const deleteNode: (metadata: ITypeMetadata, node: Node) => ITypeMetadata;
+declare const addNodes: (metadata: ITypeMetadata | undefined, nodes: Array<Node>) => ITypeMetadata;
+declare const isEmpty: ({ fieldMap }: {
+    fieldMap: any;
+}) => boolean;
+declare const hasNodes: (typeMetadata: ITypeMetadata) => boolean;
+declare const haveEqualFields: ({ fieldMap }?: {
+    fieldMap?: {} | undefined;
+}, { fieldMap: otherFieldMap }?: {
+    fieldMap?: {} | undefined;
+}) => boolean;
+declare const initialMetadata: (state?: object | undefined) => ITypeMetadata;
+export { addNode, addNodes, deleteNode, ignore, disable, isEmpty, hasNodes, haveEqualFields, initialMetadata, };

package/dist/schema/infer/type-conflict-reporter.d.ts

@@ -1,28 +1,28 @@
-import { Node } from "../../../index";
-export interface ITypeConflictExample {
-    value: unknown;
-    type: string;
-    parent?: Node;
-    arrayTypes?: Array<string>;
-}
-interface ITypeConflict {
-    value: unknown;
-    description?: string;
-}
-declare class TypeConflictEntry {
-    selector: string;
-    types: Map<string, ITypeConflict>;
-    constructor(selector: string);
-    addExample({ value, type, parent }: ITypeConflictExample): void;
-    printEntry(): void;
-}
-declare class TypeConflictReporter {
-    entries: Map<string, TypeConflictEntry>;
-    constructor();
-    clearConflicts(): void;
-    getEntryFromSelector(selector: string): TypeConflictEntry;
-    addConflict(selector: string, examples: Array<ITypeConflictExample>): void;
-    printConflicts(): void;
-    getConflicts(): Array<TypeConflictEntry>;
-}
-export { TypeConflictReporter, TypeConflictEntry };
+import { Node } from "../../../index";
+export interface ITypeConflictExample {
+    value: unknown;
+    type: string;
+    parent?: Node;
+    arrayTypes?: Array<string>;
+}
+interface ITypeConflict {
+    value: unknown;
+    description?: string;
+}
+declare class TypeConflictEntry {
+    selector: string;
+    types: Map<string, ITypeConflict>;
+    constructor(selector: string);
+    addExample({ value, type, parent }: ITypeConflictExample): void;
+    printEntry(): void;
+}
+declare class TypeConflictReporter {
+    entries: Map<string, TypeConflictEntry>;
+    constructor();
+    clearConflicts(): void;
+    getEntryFromSelector(selector: string): TypeConflictEntry;
+    addConflict(selector: string, examples: Array<ITypeConflictExample>): void;
+    printConflicts(): void;
+    getConflicts(): Array<TypeConflictEntry>;
+}
+export { TypeConflictReporter, TypeConflictEntry };

package/dist/schema/resolvers.d.ts

@@ -1,34 +1,34 @@
-import { GraphQLList, GraphQLFieldConfig } from "graphql";
-import { GatsbyResolver, IGatsbyConnection, IGatsbyResolverContext } from "./type-definitions";
-export declare function findMany<TSource, TArgs>(typeName: string): GatsbyResolver<TSource, TArgs>;
-export declare function findOne<TSource, TArgs>(typeName: string): GatsbyResolver<TSource, TArgs>;
-declare type PaginatedArgs<TArgs> = TArgs & {
-    skip?: number;
-    limit?: number;
-};
-export declare function findManyPaginated<TSource, TArgs, TNodeType>(typeName: string): GatsbyResolver<TSource, PaginatedArgs<TArgs>>;
-interface IFieldConnectionArgs {
-    field: string;
-}
-export declare const distinct: GatsbyResolver<IGatsbyConnection<any>, IFieldConnectionArgs>;
-export declare const group: GatsbyResolver<IGatsbyConnection<any>, PaginatedArgs<IFieldConnectionArgs>>;
-export declare function paginate<NodeType>(results: NodeType[] | undefined, { skip, limit }: {
-    skip?: number;
-    limit?: number;
-}): IGatsbyConnection<NodeType>;
-export declare function link<TSource, TArgs>(options: {
-    by: string;
-    type?: import("graphql").GraphQLScalarType | import("graphql").GraphQLObjectType<any, any, {
-        [key: string]: any;
-    }> | import("graphql").GraphQLInterfaceType | import("graphql").GraphQLUnionType | import("graphql").GraphQLEnumType | import("graphql").GraphQLInputObjectType | GraphQLList<any> | import("graphql").GraphQLNonNull<any> | undefined;
-    from?: string | undefined;
-    fromNode?: string | undefined;
-} | undefined, fieldConfig: GraphQLFieldConfig<TSource, IGatsbyResolverContext<TSource, TArgs>, TArgs>): GatsbyResolver<TSource, TArgs>;
-export declare function fileByPath<TSource, TArgs>(options: {
-    from?: string | undefined;
-    fromNode?: string | undefined;
-} | undefined, fieldConfig: any): GatsbyResolver<TSource, TArgs>;
-export declare const defaultFieldResolver: GatsbyResolver<any, any>;
-export declare function wrappingResolver<TSource, TArgs>(resolver: GatsbyResolver<TSource, TArgs>): GatsbyResolver<TSource, TArgs>;
-export declare const defaultResolver: GatsbyResolver<any, any>;
-export {};
+import { GraphQLList, GraphQLFieldConfig } from "graphql";
+import { GatsbyResolver, IGatsbyConnection, IGatsbyResolverContext } from "./type-definitions";
+export declare function findMany<TSource, TArgs>(typeName: string): GatsbyResolver<TSource, TArgs>;
+export declare function findOne<TSource, TArgs>(typeName: string): GatsbyResolver<TSource, TArgs>;
+declare type PaginatedArgs<TArgs> = TArgs & {
+    skip?: number;
+    limit?: number;
+};
+export declare function findManyPaginated<TSource, TArgs, TNodeType>(typeName: string): GatsbyResolver<TSource, PaginatedArgs<TArgs>>;
+interface IFieldConnectionArgs {
+    field: string;
+}
+export declare const distinct: GatsbyResolver<IGatsbyConnection<any>, IFieldConnectionArgs>;
+export declare const group: GatsbyResolver<IGatsbyConnection<any>, PaginatedArgs<IFieldConnectionArgs>>;
+export declare function paginate<NodeType>(results: NodeType[] | undefined, { skip, limit }: {
+    skip?: number;
+    limit?: number;
+}): IGatsbyConnection<NodeType>;
+export declare function link<TSource, TArgs>(options: {
+    by: string;
+    type?: import("graphql").GraphQLScalarType | import("graphql").GraphQLObjectType<any, any, {
+        [key: string]: any;
+    }> | import("graphql").GraphQLInterfaceType | import("graphql").GraphQLUnionType | import("graphql").GraphQLEnumType | import("graphql").GraphQLInputObjectType | GraphQLList<any> | import("graphql").GraphQLNonNull<any> | undefined;
+    from?: string | undefined;
+    fromNode?: string | undefined;
+} | undefined, fieldConfig: GraphQLFieldConfig<TSource, IGatsbyResolverContext<TSource, TArgs>, TArgs>): GatsbyResolver<TSource, TArgs>;
+export declare function fileByPath<TSource, TArgs>(options: {
+    from?: string | undefined;
+    fromNode?: string | undefined;
+} | undefined, fieldConfig: any): GatsbyResolver<TSource, TArgs>;
+export declare const defaultFieldResolver: GatsbyResolver<any, any>;
+export declare function wrappingResolver<TSource, TArgs>(resolver: GatsbyResolver<TSource, TArgs>): GatsbyResolver<TSource, TArgs>;
+export declare const defaultResolver: GatsbyResolver<any, any>;
+export {};

package/dist/schema/type-definitions.d.ts

@@ -1,42 +1,42 @@
-import { GraphQLResolveInfo } from "graphql";
-import { IPhantomReporter } from "gatsby-cli/lib/reporter/reporter-phantom";
-import { IGraphQLRunnerStats } from "../query/types";
-import { Path } from "graphql/jsutils/Path";
-export interface IGatsbyResolverContext<TSource, TArgs> {
-    defaultFieldResolver: GatsbyResolver<TSource, TArgs>;
-    nodeModel: any;
-    stats: IGraphQLRunnerStats | null;
-    tracer: IGraphQLSpanTracer | null;
-    [key: string]: any;
-}
-export declare type GatsbyGraphQLResolveInfo = GraphQLResolveInfo & {
-    from?: string;
-    fromNode?: string;
-};
-export declare type GatsbyResolver<TSource, TArgs = {
-    [argName: string]: any;
-}> = (source: TSource, args: TArgs, context: IGatsbyResolverContext<TSource, TArgs>, info: GatsbyGraphQLResolveInfo) => any;
-export interface IGatsbyConnection<NodeType> {
-    totalCount: number;
-    edges: Array<IGatsbyEdge<NodeType>>;
-    nodes: Array<NodeType>;
-    pageInfo: IGatsbyPageInfo;
-}
-export interface IGatsbyEdge<NodeType> {
-    node: NodeType;
-    next: NodeType | undefined;
-    previous: NodeType | undefined;
-}
-export interface IGatsbyPageInfo {
-    currentPage: number;
-    hasPreviousPage: boolean;
-    hasNextPage: boolean;
-    itemCount: number;
-    pageCount: number;
-    perPage: number | undefined;
-    totalCount: number;
-}
-export interface IGraphQLSpanTracer {
-    getParentActivity(): IPhantomReporter;
-    createResolverActivity(path: Path, name: string): IPhantomReporter;
-}
+import { GraphQLResolveInfo } from "graphql";
+import { IPhantomReporter } from "gatsby-cli/lib/reporter/reporter-phantom";
+import { IGraphQLRunnerStats } from "../query/types";
+import { Path } from "graphql/jsutils/Path";
+export interface IGatsbyResolverContext<TSource, TArgs> {
+    defaultFieldResolver: GatsbyResolver<TSource, TArgs>;
+    nodeModel: any;
+    stats: IGraphQLRunnerStats | null;
+    tracer: IGraphQLSpanTracer | null;
+    [key: string]: any;
+}
+export declare type GatsbyGraphQLResolveInfo = GraphQLResolveInfo & {
+    from?: string;
+    fromNode?: string;
+};
+export declare type GatsbyResolver<TSource, TArgs = {
+    [argName: string]: any;
+}> = (source: TSource, args: TArgs, context: IGatsbyResolverContext<TSource, TArgs>, info: GatsbyGraphQLResolveInfo) => any;
+export interface IGatsbyConnection<NodeType> {
+    totalCount: number;
+    edges: Array<IGatsbyEdge<NodeType>>;
+    nodes: Array<NodeType>;
+    pageInfo: IGatsbyPageInfo;
+}
+export interface IGatsbyEdge<NodeType> {
+    node: NodeType;
+    next: NodeType | undefined;
+    previous: NodeType | undefined;
+}
+export interface IGatsbyPageInfo {
+    currentPage: number;
+    hasPreviousPage: boolean;
+    hasNextPage: boolean;
+    itemCount: number;
+    pageCount: number;
+    perPage: number | undefined;
+    totalCount: number;
+}
+export interface IGraphQLSpanTracer {
+    getParentActivity(): IPhantomReporter;
+    createResolverActivity(path: Path, name: string): IPhantomReporter;
+}

package/dist/schema/types/date.d.ts

@@ -1,40 +1,40 @@
-import { MomentInput } from "moment";
-import { GraphQLScalarType, GraphQLFieldConfig } from "graphql";
-interface IDateResolverOption {
-    locale?: string;
-    formatString?: string;
-    fromNow?: string;
-    difference?: string;
-    from?: string;
-    fromNode?: {
-        type: string;
-        defaultValue: boolean;
-    };
-}
-declare type DateResolverFieldConfig = GraphQLFieldConfig<any, any, any>;
-declare type DateResolver = (source: any, args: any, context: any, info: any) => Promise<null | string | number | Array<string | number>>;
-export declare const GraphQLDate: GraphQLScalarType;
-/**
- * looksLikeADate isn't a 100% valid check if it is a real date but at least it's something that looks like a date.
- * It won't catch values like 2010-02-30
- * 1) is it a number?
- * 2) does the length of the value comply with any of our formats
- * 3) does the str starts with 4 digites (YYYY)
- * 4) does the str ends with something that looks like a date
- * 5) Small regex to see if it matches any of the formats
- * 6) check momentjs
- *
- * @param {*} value
- * @return {boolean}
- */
-export declare function looksLikeADate(value?: string): boolean;
-/**
- * @param {*} value
- * @return {boolean}
- */
-export declare function isDate(value: MomentInput): boolean;
-export declare const getDateResolver: (options: IDateResolverOption | undefined, fieldConfig: DateResolverFieldConfig) => {
-    args: Record<string, any>;
-    resolve: DateResolver;
-};
-export {};
+import { MomentInput } from "moment";
+import { GraphQLScalarType, GraphQLFieldConfig } from "graphql";
+interface IDateResolverOption {
+    locale?: string;
+    formatString?: string;
+    fromNow?: string;
+    difference?: string;
+    from?: string;
+    fromNode?: {
+        type: string;
+        defaultValue: boolean;
+    };
+}
+declare type DateResolverFieldConfig = GraphQLFieldConfig<any, any, any>;
+declare type DateResolver = (source: any, args: any, context: any, info: any) => Promise<null | string | number | Array<string | number>>;
+export declare const GraphQLDate: GraphQLScalarType;
+/**
+ * looksLikeADate isn't a 100% valid check if it is a real date but at least it's something that looks like a date.
+ * It won't catch values like 2010-02-30
+ * 1) is it a number?
+ * 2) does the length of the value comply with any of our formats
+ * 3) does the str starts with 4 digites (YYYY)
+ * 4) does the str ends with something that looks like a date
+ * 5) Small regex to see if it matches any of the formats
+ * 6) check momentjs
+ *
+ * @param {*} value
+ * @return {boolean}
+ */
+export declare function looksLikeADate(value?: string): boolean;
+/**
+ * @param {*} value
+ * @return {boolean}
+ */
+export declare function isDate(value: MomentInput): boolean;
+export declare const getDateResolver: (options: IDateResolverOption | undefined, fieldConfig: DateResolverFieldConfig) => {
+    args: Record<string, any>;
+    resolve: DateResolver;
+};
+export {};

package/dist/schema/types/derived-types.d.ts

@@ -1,42 +1,42 @@
-/**
- * Derived types are types that make sense only when their base type exists
- *
- * Take this node for example:
- * {
- *   internal: { type: 'Foo' },
- *   fields: {
- *     bar: "string",
- *   }
- * }
- *
- * It will produce following types:
- * Foo
- * FooFields
- *
- * FooInputFilter
- * FooSortInput
- *
- * FooFieldsInputFilter
- * FooFieldsSortFilter
- * etc
- *
- * Derived types:
- *   Foo: FooFields, FooInputFilter, FooSortInput
- *   FooFields: FooFieldsInputFilter, FooFieldsSortFilter
- *
- * Caveats:
- *   Only types created via inference are marked as derived. So if in the example above
- *   user explicitly defines `FooFields` type (via `createTypes` call) it won't be considered
- *   a derived type
- */
-import { ObjectTypeComposer, InterfaceTypeComposer, ScalarTypeComposer, SchemaComposer, InputTypeComposer, EnumTypeComposer, UnionTypeComposer } from "graphql-compose";
-declare type AllTypeComposer = ObjectTypeComposer | InputTypeComposer | EnumTypeComposer | InterfaceTypeComposer | UnionTypeComposer | ScalarTypeComposer;
-export declare const clearDerivedTypes: ({ schemaComposer, typeComposer, }: {
-    schemaComposer: SchemaComposer<any>;
-    typeComposer: AllTypeComposer;
-}) => void;
-export declare const addDerivedType: ({ typeComposer, derivedTypeName, }: {
-    typeComposer: AllTypeComposer;
-    derivedTypeName: string;
-}) => void;
-export {};
+/**
+ * Derived types are types that make sense only when their base type exists
+ *
+ * Take this node for example:
+ * {
+ *   internal: { type: 'Foo' },
+ *   fields: {
+ *     bar: "string",
+ *   }
+ * }
+ *
+ * It will produce following types:
+ * Foo
+ * FooFields
+ *
+ * FooInputFilter
+ * FooSortInput
+ *
+ * FooFieldsInputFilter
+ * FooFieldsSortFilter
+ * etc
+ *
+ * Derived types:
+ *   Foo: FooFields, FooInputFilter, FooSortInput
+ *   FooFields: FooFieldsInputFilter, FooFieldsSortFilter
+ *
+ * Caveats:
+ *   Only types created via inference are marked as derived. So if in the example above
+ *   user explicitly defines `FooFields` type (via `createTypes` call) it won't be considered
+ *   a derived type
+ */
+import { ObjectTypeComposer, InterfaceTypeComposer, ScalarTypeComposer, SchemaComposer, InputTypeComposer, EnumTypeComposer, UnionTypeComposer } from "graphql-compose";
+declare type AllTypeComposer = ObjectTypeComposer | InputTypeComposer | EnumTypeComposer | InterfaceTypeComposer | UnionTypeComposer | ScalarTypeComposer;
+export declare const clearDerivedTypes: ({ schemaComposer, typeComposer, }: {
+    schemaComposer: SchemaComposer<any>;
+    typeComposer: AllTypeComposer;
+}) => void;
+export declare const addDerivedType: ({ typeComposer, derivedTypeName, }: {
+    typeComposer: AllTypeComposer;
+    derivedTypeName: string;
+}) => void;
+export {};

package/dist/schema/types/filter.d.ts

@@ -1,12 +1,12 @@
-import { InputTypeComposer, SchemaComposer, ObjectTypeComposer, InterfaceTypeComposer } from "graphql-compose";
-declare type Context = any;
-export declare const SEARCHABLE_ENUM: {
-    readonly SEARCHABLE: "SEARCHABLE";
-    readonly NOT_SEARCHABLE: "NON_SEARCHABLE";
-    readonly DEPRECATED_SEARCHABLE: "DERPECATED_SEARCHABLE";
-};
-export declare const getFilterInput: ({ schemaComposer, typeComposer, }: {
-    schemaComposer: SchemaComposer<Context>;
-    typeComposer: ObjectTypeComposer<Context> | InterfaceTypeComposer<Context>;
-}) => InputTypeComposer;
-export {};
+import { InputTypeComposer, SchemaComposer, ObjectTypeComposer, InterfaceTypeComposer } from "graphql-compose";
+declare type Context = any;
+export declare const SEARCHABLE_ENUM: {
+    readonly SEARCHABLE: "SEARCHABLE";
+    readonly NOT_SEARCHABLE: "NON_SEARCHABLE";
+    readonly DEPRECATED_SEARCHABLE: "DERPECATED_SEARCHABLE";
+};
+export declare const getFilterInput: ({ schemaComposer, typeComposer, }: {
+    schemaComposer: SchemaComposer<Context>;
+    typeComposer: ObjectTypeComposer<Context> | InterfaceTypeComposer<Context>;
+}) => InputTypeComposer;
+export {};

package/dist/schema/types/node-interface.d.ts

@@ -1,14 +1,14 @@
-import { SchemaComposer, InterfaceTypeComposer, ObjectTypeComposer } from "graphql-compose";
-import { IGatsbyResolverContext } from "../type-definitions";
-export declare const NodeInterfaceFields: string[];
-export declare const addNodeInterfaceFields: <TSource = any, TArgs = any>({ schemaComposer, typeComposer, }: {
-    schemaComposer: SchemaComposer<IGatsbyResolverContext<TSource, TArgs>>;
-    typeComposer: ObjectTypeComposer;
-}) => void;
-export declare const addNodeInterface: <TSource = any, TArgs = any>({ schemaComposer, typeComposer, }: {
-    schemaComposer: SchemaComposer<IGatsbyResolverContext<TSource, TArgs>>;
-    typeComposer: ObjectTypeComposer;
-}) => void;
-export declare const getNodeInterface: <TSource = any, TContext = any, TArgs = any>({ schemaComposer, }: {
-    schemaComposer: SchemaComposer<IGatsbyResolverContext<TSource, TArgs>>;
-}) => InterfaceTypeComposer<TSource, TContext>;
+import { SchemaComposer, InterfaceTypeComposer, ObjectTypeComposer } from "graphql-compose";
+import { IGatsbyResolverContext } from "../type-definitions";
+export declare const NodeInterfaceFields: string[];
+export declare const addNodeInterfaceFields: <TSource = any, TArgs = any>({ schemaComposer, typeComposer, }: {
+    schemaComposer: SchemaComposer<IGatsbyResolverContext<TSource, TArgs>>;
+    typeComposer: ObjectTypeComposer;
+}) => void;
+export declare const addNodeInterface: <TSource = any, TArgs = any>({ schemaComposer, typeComposer, }: {
+    schemaComposer: SchemaComposer<IGatsbyResolverContext<TSource, TArgs>>;
+    typeComposer: ObjectTypeComposer;
+}) => void;
+export declare const getNodeInterface: <TSource = any, TContext = any, TArgs = any>({ schemaComposer, }: {
+    schemaComposer: SchemaComposer<IGatsbyResolverContext<TSource, TArgs>>;
+}) => InterfaceTypeComposer<TSource, TContext>;

package/dist/schema/types/sort.d.ts

@@ -1,18 +1,18 @@
-import { SchemaComposer, EnumTypeComposer, ObjectTypeComposer, InputTypeComposer, InterfaceTypeComposer } from "graphql-compose";
-export declare const SORTABLE_ENUM: {
-    SORTABLE: string;
-    NOT_SORTABLE: string;
-    DEPRECATED_SORTABLE: string;
-};
-export declare const getSortOrderEnum: <TContext = any>({ schemaComposer, }: {
-    schemaComposer: SchemaComposer<TContext>;
-}) => EnumTypeComposer<TContext>;
-export declare const getFieldsEnum: <TSource = any, TContext = any>({ schemaComposer, typeComposer, inputTypeComposer, }: {
-    schemaComposer: SchemaComposer<TContext>;
-    typeComposer: ObjectTypeComposer<TSource, TContext> | InterfaceTypeComposer<TSource, TContext>;
-    inputTypeComposer: InputTypeComposer<TContext>;
-}) => EnumTypeComposer<TContext>;
-export declare const getSortInput: <TSource = any, TContext = any>({ schemaComposer, typeComposer, }: {
-    schemaComposer: SchemaComposer<TContext>;
-    typeComposer: ObjectTypeComposer<TSource, TContext>;
-}) => InputTypeComposer<TContext>;
+import { SchemaComposer, EnumTypeComposer, ObjectTypeComposer, InputTypeComposer, InterfaceTypeComposer } from "graphql-compose";
+export declare const SORTABLE_ENUM: {
+    SORTABLE: string;
+    NOT_SORTABLE: string;
+    DEPRECATED_SORTABLE: string;
+};
+export declare const getSortOrderEnum: <TContext = any>({ schemaComposer, }: {
+    schemaComposer: SchemaComposer<TContext>;
+}) => EnumTypeComposer<TContext>;
+export declare const getFieldsEnum: <TSource = any, TContext = any>({ schemaComposer, typeComposer, inputTypeComposer, }: {
+    schemaComposer: SchemaComposer<TContext>;
+    typeComposer: ObjectTypeComposer<TSource, TContext> | InterfaceTypeComposer<TSource, TContext>;
+    inputTypeComposer: InputTypeComposer<TContext>;
+}) => EnumTypeComposer<TContext>;
+export declare const getSortInput: <TSource = any, TContext = any>({ schemaComposer, typeComposer, }: {
+    schemaComposer: SchemaComposer<TContext>;
+    typeComposer: ObjectTypeComposer<TSource, TContext>;
+}) => InputTypeComposer<TContext>;