fuse

• ListResultShape

  interface ListResultShape<T> {
      totalCount?: number | null;
      nodes: MaybePromise<T>[];
  }

• StellateOptions

  interface StellateOptions {
      loggingToken: string;
      serviceName: string;
  }

• Scopes

  /**
   * An overridable type, which will be used in all your schema-building functions to inform
   * you what scopes are available to be used.
   *
   * @example
   * ```ts
   * import 'fuse'
   * import { defineAuthScopes, Scopes } from 'fuse'
   *
   * declare module 'fuse' {
   *   export interface Scopes {
   *     isLoggedIn: boolean
   *   }
   * }
   * ```
   */
  interface Scopes {
  }

• InputObjectTypeOptions

  interface InputObjectTypeOptions<Types extends SchemaTypes = BuilderTypes, Fields extends InputFieldMap = InputFieldMap> {
      isOneOf?: boolean;
      fields: (t: InputFieldBuilder<Types, "InputObject">) => Fields;
      description?: string;
      extensions?: Readonly<Record<string, unknown>>;
  }

• ListShape

  type ListShape<Types extends SchemaTypes, T, Nullable, ListResult extends ListResultShape<T> = ListResultShape<T>> = (Nullable extends false ? never : null | undefined) | (ListResult & Types["ListWrapper"]);

• ListShapeForType

  type ListShapeForType<Types extends SchemaTypes, Type extends OutputType<Types>, Nullable extends boolean, ListResult extends ListResultShape<ShapeFromTypeParam<Types, Type, Nullable>> = ListResultShape<ShapeFromTypeParam<Types, Type, Nullable>>> = ListShape<Types, ShapeFromTypeParam<Types, Type, Nullable>, Nullable, ListResult>;

• InitialContext

  type InitialContext = {
      headers: Headers;
      params: GraphQLParams;
      request: YogaInitialContext["request"];
  };

• UserContext

  type UserContext = Record<string, any>;

• GetContext

  type GetContext<AdditionalContext> = ((ctx: InitialContext) => UserContext & AdditionalContext) | ((ctx: InitialContext) => Promise<UserContext & AdditionalContext>) | (UserContext & AdditionalContext);

• Builder

  type Builder = Omit<typeof builder, "addScalarType" | "loadableInterface" | "loadableUnion" | "objectType" | "loadableInterfaceRef" | "loadableObjectRef" | "nodeInterfaceRef" | "inputRef" | "objectRef" | "scalarType" | "interfaceField" | "listObject" | "node" | "options" | "pageInfoRef" | "subscriptionType" | "queryFields" | "queryType" | "mutationType" | "mutationFields" | "connectionObject" | "edgeObject" | "configStore" | "defaultFieldNullability" | "defaultInputFieldRequiredness" | "globalConnectionField" | "globalConnectionFields" | "args" | "loadableNode" | "loadableNodeRef" | "interfaceFields" | "subscriptionFields" | "subscriptionField" | "relayMutationField" | "enumType" | "inputType" | "interfaceRef" | "interfaceType" | "loadableObject" | "mutationField" | "mutationFields" | "objectField" | "objectFields" | "queryField" | "unionType">;

• BuilderTypes

  type BuilderTypes = typeof builder extends PothosSchemaTypes.SchemaBuilder<infer T> ? T : never;

• defineAuthScopes

  /**
   * A function to define auth-scopes that can be used throughout your schema
   * definition to authorize both fields as well as types.
   *
   * @remarks
   * This function should only be called once and will carry your scope-definitions for
   * the lifetime of the application.
   *
   * @example
   * ```ts
   * defineAuthScopes((ctx) => ({ isLoggedIn: !!ctx.user }))
   * addQueryFields((t) => ({
   *   me: t.field({
   *     type: User,
   *     authScopes: {
   *       isLoggedIn: true,
   *     },
   *     resolve: async (_, args, context) => {
   *       // return the user
   *     }
   *   }),
   * }))
   * ```
   */
  declare const defineAuthScopes: (func: (ctx: any) => Promise<Scopes> | Scopes) => void;

• node

  /** A function to create a keyed object, this will inherit from the `Node` interface and hence be
   * query-able from `node(id: ID!): Node` and `nodes(ids: [ID!]!): [Node]`. Additionally a Query.typeName
   * will be created that you can query with (id: ID!).
   *
   * @remarks
   * This is a helper function to create a node with an associated way to fetch it.
   * Nodes get assigned a unique ID which is derived from `base64Encode(nameOfType + node[key || 'id'])`.
   * The fields property can be used to rename properties, type them and even create custom resolve functions
   * for computed properties or transformations.
   * Optionally when the output-type has no `id` property you can use the `key` option to specify a different
   * property used to uniquely identify the node.
   *
   * @example
   * ```ts
   * export const LaunchNode = node<OutputType, typeof key>({
   *   name: 'Launch',
   *   key: 'flight_number',
   *   async load(ids) {
   *     // get and return the data
   *   }
   *   fields: (t) => ({
   *     // we tell our node that it can find the name on a different property named mission_name and to
   *     // expose it as a string.
   *     name: t.exposeString('mission_name'),
   *     details: t.exposeString('details', { nullable: true }),
   *     image: t.field({
   *      type: 'String',
   *       resolve: (parent) => parent.links.mission_patch,
   *     }),
   *     launchDate: t.exposeString('launch_date_utc'),
   *   }),
   * })
   * ```
   */
  declare function node<T extends {}, Key extends string | number = string, Interfaces extends InterfaceParam<BuilderTypes>[] = InterfaceParam<BuilderTypes>[]>(opts: ("id" extends keyof T ? {
      name: string;
      key?: keyof T;
      description?: string;
      load: (ids: Array<string | Key>, ctx: Record<string, unknown>) => Promise<Array<T | Error>>;
  } : {
      name: string;
      key: keyof T;
      description?: string;
      load: (ids: Array<string | Key>, ctx: Record<string, unknown>) => Promise<Array<T | Error>>;
  }) & Pick<LoadableNodeOptions<BuilderTypes, T, Interfaces, string, string | number, string | number, string | number>, "authScopes" | "fields" | "interfaces" | "isTypeOf">): Omit<_pothos_plugin_dataloader.ImplementableLoadableNodeRef<PothosSchemaTypes.ExtendDefaultTypes<{
      Context: {
          request: Request;
          params: GraphQLParams<Record<string, any>, Record<string, any>>;
      } & UserContext;
      AuthScopes: Scopes;
      DefaultFieldNullability: true;
      Scalars: {
          JSON: {
              Input: unknown;
              Output: unknown;
          };
          Date: {
              Input: Date;
              Output: Date;
          };
      };
  }>, T | Key, T, string, Key, Key>, "implement">;

• objectType

  /**
   * A function to create an (unkeyed) object that can be resolved, this can subsequently be used in a
   * query/mutation/node/...
   *
   * @example
   * ```ts
   * const Location = objectType<Resource['location']>({
   *   name: 'Location',
   *   fields: (t) => ({
   *     name: t.exposeString('name'),
   *     region: t.exposeString('region'),
   *     latitude: t.exposeFloat('latitude'),
   *     longitude: t.exposeFloat('longitude'),
   *   }),
   *})
   * ```
   */
  declare function objectType<T, Interfaces extends InterfaceParam<BuilderTypes>[] = InterfaceParam<BuilderTypes>[]>(opts: {
      name: string;
  } & Omit<ObjectTypeOptions<BuilderTypes, ImplementableObjectRef<BuilderTypes, T, T>, T, Interfaces>, "name">): PothosSchemaTypes.ObjectRef<T, T>;

• enumType

  /**
   * Narrow down the possible values of a field by providing an enum.
   *
   * @example
   * ```ts
   * const SiteStatus = enumType({
   *  name: 'SiteStatus',
   *  description: 'Describes the Status of a given Launch Site',
   *  values: ['ACTIVE', 'INACTIVE', 'UNKNOWN'] as const
   * })
   *
   * // Which can then be used like
   * t.field({
   *   type: SiteStatus,
   *   resolve: (parent) => {
   *     switch (parent.status) {
   *       case 'active':
   *         return 'ACTIVE'
   *       case 'inactive':
   *         return 'INACTIVE'
   *       default:
   *         return 'UNKNOWN'
   *      }
   *    },
   * }),
   * ```
   */
  declare const enumType: <Values extends EnumValues<PothosSchemaTypes.ExtendDefaultTypes<{
      Context: {
          request: Request;
          params: GraphQLParams;
      } & UserContext;
      AuthScopes: Scopes;
      DefaultFieldNullability: true;
      Scalars: {
          JSON: {
              Input: unknown;
              Output: unknown;
          };
          Date: {
              Input: Date;
              Output: Date;
          };
      };
  }>>>(opts: {
      name: string;
  } & PothosSchemaTypes.EnumTypeOptions<PothosSchemaTypes.ExtendDefaultTypes<{
      Context: {
          request: Request;
          params: GraphQLParams;
      } & UserContext;
      AuthScopes: Scopes;
      DefaultFieldNullability: true;
      Scalars: {
          JSON: {
              Input: unknown;
              Output: unknown;
          };
          Date: {
              Input: Date;
              Output: Date;
          };
      };
  }>, Values>) => EnumRef<ShapeFromEnumValues<PothosSchemaTypes.ExtendDefaultTypes<{
      Context: {
          request: Request;
          params: GraphQLParams;
      } & UserContext;
      AuthScopes: Scopes;
      DefaultFieldNullability: true;
      Scalars: {
          JSON: {
              Input: unknown;
              Output: unknown;
          };
          Date: {
              Input: Date;
              Output: Date;
          };
      };
  }>, Values>>;

• inputType

  /**
   * Creates a re-usable input-type that can be used in arguments to your fields.
   *
   * @example
   * ```ts
   * const Pagination = inputType({
   *   description: 'The default pagination input type, allowing you to specify a limit and offset',
   *   name: 'Pagination',
   *   fields: (t) => ({
   *     limit: t.int({ default: 10 }),
   *     offset: t.int({ default: 0 })
   *   })
   * })
   *
   * addQueryFields((t) => ({
   *   myList: t.list({
   *     args: input: t.arg({ type: Pagination })
   *   })
   * })
   * ```
   */
  declare const inputType: <Fields extends InputFieldMap>(opts: {
      name: string;
  } & InputObjectTypeOptions<PothosSchemaTypes.ExtendDefaultTypes<{
      Context: {
          request: Request;
          params: GraphQLParams;
      } & UserContext;
      AuthScopes: Scopes;
      DefaultFieldNullability: true;
      Scalars: {
          JSON: {
              Input: unknown;
              Output: unknown;
          };
          Date: {
              Input: Date;
              Output: Date;
          };
      };
  }>, Fields>) => InputObjectRef<InputShapeFromFields<Fields>>;

• interfaceType

  /**
   * Creates an interface-type which can be used in the `interfaces` option of `object` and `node`.
   *
   * @example
   * ```ts
   * const NewInterface = interfaceType<Shape, Parent>({
   *   name: 'NewInterface',
   *   resolveType: (parent) => 'Launch',
   *   fields: (t) => ({
   *     name: t.string()
   *   }),
   * })
   * ```
   */
  declare const interfaceType: (opts: Parameters<(typeof builder)["interfaceType"]>["1"] & {
      name: string;
  }) => _pothos_core_dts_refs_interface.default<unknown, unknown>;

• unionType

  /**
   * Creates a union of types, these can be used in fields and will then have to resolve to
   * one of the union types.
   *
   * @example
   * ```ts
   * const NewInterface = unionType({
   *   name: 'Resource',
   *   resolveType: (parent) => 'Engine',
   *   types: [Fuel, Engine]
   * })
   * ```
   */
  declare const unionType: (opts: Parameters<(typeof builder)["unionType"]>["1"] & {
      name: string;
  }) => _pothos_core_dts_refs_union.default<any, any>;

import '@pothos/core'
import '@pothos/plugin-scope-auth'
import '@pothos/plugin-dataloader'
import '@pothos/plugin-relay'
import * as _pothos_core_dts_refs_union from '@pothos/core/dts/refs/union';
import * as _pothos_core_dts_refs_interface from '@pothos/core/dts/refs/interface';
import * as _pothos_plugin_dataloader from '@pothos/plugin-dataloader';
import { LoadableNodeOptions } from '@pothos/plugin-dataloader';
import { MaybePromise, SchemaTypes, OutputType, ShapeFromTypeParam, BasePlugin, InputFieldMap, Resolver, InputShapeFromFields, FieldKind, FieldOptionsFromKind, InputFieldsFromShape, FieldRef, InterfaceParam, ObjectTypeOptions, ImplementableObjectRef, EnumValues, EnumRef, ShapeFromEnumValues, InputObjectRef, InputFieldBuilder } from '@pothos/core';
import { GraphQLParams, YogaInitialContext } from 'graphql-yoga';
export { decodeGlobalID, encodeGlobalID } from '@pothos/plugin-relay';
import { GraphQLError } from 'graphql';

interface ListResultShape<T> {
    totalCount?: number | null;
    nodes: MaybePromise<T>[];
}
type ListShape<Types extends SchemaTypes, T, Nullable, ListResult extends ListResultShape<T> = ListResultShape<T>> = (Nullable extends false ? never : null | undefined) | (ListResult & Types['ListWrapper']);
type ListShapeForType<Types extends SchemaTypes, Type extends OutputType<Types>, Nullable extends boolean, ListResult extends ListResultShape<ShapeFromTypeParam<Types, Type, Nullable>> = ListResultShape<ShapeFromTypeParam<Types, Type, Nullable>>> = ListShape<Types, ShapeFromTypeParam<Types, Type, Nullable>, Nullable, ListResult>;

declare class PothosListPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
}

declare global {
    export namespace PothosSchemaTypes {
        interface Plugins<Types extends SchemaTypes> {
            fuselist: PothosListPlugin<Types>;
        }
        interface UserSchemaTypes {
            ListWrapper: {};
        }
        interface SchemaBuilder<Types extends SchemaTypes> {
            listObject: <Type extends OutputType<Types>, NodeNullable extends boolean>(listOptions: {
                name: string;
                type: Type;
                nullable: NodeNullable;
            }) => ObjectRef<ListShapeForType<Types, Type, NodeNullable>>;
        }
        interface ListFieldOptions<Types extends SchemaTypes, ParentShape, Type extends OutputType<Types>, Nullable extends boolean, NodeNullability extends boolean, Args extends InputFieldMap, ResolveReturnShape, ConnectionResult extends ListResultShape<ShapeFromTypeParam<Types, Type, NodeNullability>> = ListResultShape<ShapeFromTypeParam<Types, Type, NodeNullability>>> {
            type: Type;
            args?: Args;
            nullable?: Nullable;
            nodeNullable?: NodeNullability;
            resolve: Resolver<ParentShape, InputShapeFromFields<Args>, Types['Context'], ListShapeForType<Types, Type, NodeNullability, ConnectionResult>, ResolveReturnShape>;
        }
        interface RootFieldBuilder<Types extends SchemaTypes, ParentShape, Kind extends FieldKind = FieldKind> {
            list: <Type extends OutputType<Types>, Args extends InputFieldMap, Nullable extends boolean, NodeNullable extends boolean, ResolveShape, ResolveReturnShape, ConnectionResult extends ListResultShape<ShapeFromTypeParam<Types, Type, NodeNullable>> = ListResultShape<ShapeFromTypeParam<Types, Type, NodeNullable>>>(options: FieldOptionsFromKind<Types, ParentShape, Type, Nullable, InputFieldsFromShape<InputFieldMap extends Args ? {} : Args>, Kind, ResolveShape, ResolveReturnShape> extends infer FieldOptions ? ListFieldOptions<Types, FieldOptions extends {
                resolve?: (parent: infer P, ...args: any[]) => unknown;
            } ? P : unknown extends ResolveShape ? ParentShape : ResolveShape, Type, Nullable, NodeNullable, Args, ResolveReturnShape, ConnectionResult> & Omit<FieldOptions, 'args' | 'resolve' | 'type'> : never) => FieldRef<ListShapeForType<Types, Type, Nullable>>;
        }
    }
}

type InitialContext = {
    headers: Headers;
    params: GraphQLParams;
    request: YogaInitialContext['request'];
};
type UserContext = Record<string, any>;
type GetContext<AdditionalContext> = ((ctx: InitialContext) => UserContext & AdditionalContext) | ((ctx: InitialContext) => Promise<UserContext & AdditionalContext>) | (UserContext & AdditionalContext);
interface StellateOptions {
    loggingToken: string;
    serviceName: string;
}

declare abstract class FuseError extends GraphQLError {
    abstract readonly name: string;
    constructor(message: string, extensions: {
        code: string;
        http?: {
            status: number;
        };
    });
}
/** For use when user is not authenticated or unknown. */
declare class AuthenticationError extends FuseError {
    name: string;
    constructor(message?: string);
}
/** For use when a resource is not found or not accessible by an authenticated user. */
declare class ForbiddenError extends FuseError {
    name: string;
    constructor(message?: string);
}
/** For use when a resource is not found. */
declare class NotFoundError extends FuseError {
    name: string;
    constructor(message?: string);
}
/** For use when any input was invalid or when a resource does not exist but is assumed to exist. */
declare class BadRequestError extends FuseError {
    name: string;
    constructor(message?: string);
}

declare const builder: PothosSchemaTypes.SchemaBuilder<PothosSchemaTypes.ExtendDefaultTypes<{
    Context: {
        request: Request;
        params: GraphQLParams;
    } & UserContext;
    AuthScopes: Scopes;
    DefaultFieldNullability: true;
    Scalars: {
        JSON: {
            Input: unknown;
            Output: unknown;
        };
        Date: {
            Input: Date;
            Output: Date;
        };
    };
}>>;
type Builder = Omit<typeof builder, 'addScalarType' | 'loadableInterface' | 'loadableUnion' | 'objectType' | 'loadableInterfaceRef' | 'loadableObjectRef' | 'nodeInterfaceRef' | 'inputRef' | 'objectRef' | 'scalarType' | 'interfaceField' | 'listObject' | 'node' | 'options' | 'pageInfoRef' | 'subscriptionType' | 'queryFields' | 'queryType' | 'mutationType' | 'mutationFields' | 'connectionObject' | 'edgeObject' | 'configStore' | 'defaultFieldNullability' | 'defaultInputFieldRequiredness' | 'globalConnectionField' | 'globalConnectionFields' | 'args' | 'loadableNode' | 'loadableNodeRef' | 'interfaceFields' | 'subscriptionFields' | 'subscriptionField' | 'relayMutationField' | 'enumType' | 'inputType' | 'interfaceRef' | 'interfaceType' | 'loadableObject' | 'mutationField' | 'mutationFields' | 'objectField' | 'objectFields' | 'queryField' | 'unionType'>;
declare const reducedBuilder: Builder;

type BuilderTypes = typeof builder extends PothosSchemaTypes.SchemaBuilder<infer T> ? T : never;
/**
 * An overridable type, which will be used in all your schema-building functions to inform
 * you what scopes are available to be used.
 *
 * @example
 * ```ts
 * import 'fuse'
 * import { defineAuthScopes, Scopes } from 'fuse'
 *
 * declare module 'fuse' {
 *   export interface Scopes {
 *     isLoggedIn: boolean
 *   }
 * }
 * ```
 */
interface Scopes {
}
/**
 * A function to define auth-scopes that can be used throughout your schema
 * definition to authorize both fields as well as types.
 *
 * @remarks
 * This function should only be called once and will carry your scope-definitions for
 * the lifetime of the application.
 *
 * @example
 * ```ts
 * defineAuthScopes((ctx) => ({ isLoggedIn: !!ctx.user }))
 * addQueryFields((t) => ({
 *   me: t.field({
 *     type: User,
 *     authScopes: {
 *       isLoggedIn: true,
 *     },
 *     resolve: async (_, args, context) => {
 *       // return the user
 *     }
 *   }),
 * }))
 * ```
 */
declare const defineAuthScopes: (func: (ctx: any) => Promise<Scopes> | Scopes) => void;
/** A function to create a keyed object, this will inherit from the `Node` interface and hence be
 * query-able from `node(id: ID!): Node` and `nodes(ids: [ID!]!): [Node]`. Additionally a Query.typeName
 * will be created that you can query with (id: ID!).
 *
 * @remarks
 * This is a helper function to create a node with an associated way to fetch it.
 * Nodes get assigned a unique ID which is derived from `base64Encode(nameOfType + node[key || 'id'])`.
 * The fields property can be used to rename properties, type them and even create custom resolve functions
 * for computed properties or transformations.
 * Optionally when the output-type has no `id` property you can use the `key` option to specify a different
 * property used to uniquely identify the node.
 *
 * @example
 * ```ts
 * export const LaunchNode = node<OutputType, typeof key>({
 *   name: 'Launch',
 *   key: 'flight_number',
 *   async load(ids) {
 *     // get and return the data
 *   }
 *   fields: (t) => ({
 *     // we tell our node that it can find the name on a different property named mission_name and to
 *     // expose it as a string.
 *     name: t.exposeString('mission_name'),
 *     details: t.exposeString('details', { nullable: true }),
 *     image: t.field({
 *      type: 'String',
 *       resolve: (parent) => parent.links.mission_patch,
 *     }),
 *     launchDate: t.exposeString('launch_date_utc'),
 *   }),
 * })
 * ```
 */
declare function node<T extends {}, Key extends string | number = string, Interfaces extends InterfaceParam<BuilderTypes>[] = InterfaceParam<BuilderTypes>[]>(opts: ('id' extends keyof T ? {
    name: string;
    key?: keyof T;
    description?: string;
    load: (ids: Array<string | Key>, ctx: Record<string, unknown>) => Promise<Array<T | Error>>;
} : {
    name: string;
    key: keyof T;
    description?: string;
    load: (ids: Array<string | Key>, ctx: Record<string, unknown>) => Promise<Array<T | Error>>;
}) & Pick<LoadableNodeOptions<BuilderTypes, T, Interfaces, string, string | number, string | number, string | number>, 'authScopes' | 'fields' | 'interfaces' | 'isTypeOf'>): Omit<_pothos_plugin_dataloader.ImplementableLoadableNodeRef<PothosSchemaTypes.ExtendDefaultTypes<{
    Context: {
        request: Request;
        params: GraphQLParams<Record<string, any>, Record<string, any>>;
    } & UserContext;
    AuthScopes: Scopes;
    DefaultFieldNullability: true;
    Scalars: {
        JSON: {
            Input: unknown;
            Output: unknown;
        };
        Date: {
            Input: Date;
            Output: Date;
        };
    };
}>, T | Key, T, string, Key, Key>, "implement">;
/**
 * A function to create an (unkeyed) object that can be resolved, this can subsequently be used in a
 * query/mutation/node/...
 *
 * @example
 * ```ts
 * const Location = objectType<Resource['location']>({
 *   name: 'Location',
 *   fields: (t) => ({
 *     name: t.exposeString('name'),
 *     region: t.exposeString('region'),
 *     latitude: t.exposeFloat('latitude'),
 *     longitude: t.exposeFloat('longitude'),
 *   }),
 *})
 * ```
 */
declare function objectType<T, Interfaces extends InterfaceParam<BuilderTypes>[] = InterfaceParam<BuilderTypes>[]>(opts: {
    name: string;
} & Omit<ObjectTypeOptions<BuilderTypes, ImplementableObjectRef<BuilderTypes, T, T>, T, Interfaces>, 'name'>): PothosSchemaTypes.ObjectRef<T, T>;
/**
 * Add entry points to the graph, these can subsequently be used from your
 * front-end to query data.
 *
 * @example
 * ```ts
 * addQueryFields((t) => ({
 *   launches: t.list({
 *     description: 'Get a paginated list of launches.',
 *     type: LaunchNode,
 *     args: { limit: t.arg.int({ default: 10 }), offset: t.arg.int({ default: 0 }) }
 *     resolve: async (_, args) => {
 *       const data = fetch(`/launches?offset=${args.offset}&limit=${args.limit}`).then((x) => x.json()));
 *       return { nodes: data.results, totalCount: data.count }
 *     }
 *   })
 * })
 * ```
 */
declare const addQueryFields: typeof builder.queryFields;
/**
 * Add entry points to the graph, these can subsequently be used from your
 * front-end to query data.
 *
 * @example
 * ```ts
 * addMutationFields((t) => ({
 *   addToCart: t.field({
 *     description: 'Add a product to the cart.',
 *     type: Cart,
 *     args: { productId: t.arg.string() },
 *     resolve: async (_, args, context) => {
 *       const data = fetch('/cart', {
 *         method: 'POST',
 *         body: JSON.stringify({ product: args.productId }).
 *         headers: { Authorization: context.token }
 *       }).then((x) => x.json()));
 *       return data
 *     }
 *   })
 * })
 * ```
 */
declare const addMutationFields: typeof builder.mutationFields;
/**
 * Add more fields to an existing objectType.
 *
 * @example
 * ```ts
 * addObjectFields(CartObject, (t) => ({
 *   user: t.field({
 *     description: 'The user owning a certain cart.',
 *     type: User,
 *     resolve: (parent) => {
 *        const data = fetch(`/users/${parent.userId}`).then((x) => x.json()));
 *        return data;
 *     }
 *   })
 * })
 */
declare const addObjectFields: typeof builder.objectFields;
/**
 * Add more fields to an existing node.
 *
 * @example
 * ```ts
 * addNodeFields(LaunchNode, (t) => ({
 *   rocket: t.field({
 *     description: 'The rocket used for a given launch.',
 *     type: Rocket,
 *     resolve: (parent) => {
 *        const data = fetch(`/rockets/${parent.rocketId}`).then((x) => x.json()));
 *        return data;
 *     }
 *   })
 * })
 */
declare const addNodeFields: typeof builder.objectFields;
/**
 * Narrow down the possible values of a field by providing an enum.
 *
 * @example
 * ```ts
 * const SiteStatus = enumType({
 *  name: 'SiteStatus',
 *  description: 'Describes the Status of a given Launch Site',
 *  values: ['ACTIVE', 'INACTIVE', 'UNKNOWN'] as const
 * })
 *
 * // Which can then be used like
 * t.field({
 *   type: SiteStatus,
 *   resolve: (parent) => {
 *     switch (parent.status) {
 *       case 'active':
 *         return 'ACTIVE'
 *       case 'inactive':
 *         return 'INACTIVE'
 *       default:
 *         return 'UNKNOWN'
 *      }
 *    },
 * }),
 * ```
 */
declare const enumType: <Values extends EnumValues<PothosSchemaTypes.ExtendDefaultTypes<{
    Context: {
        request: Request;
        params: GraphQLParams;
    } & UserContext;
    AuthScopes: Scopes;
    DefaultFieldNullability: true;
    Scalars: {
        JSON: {
            Input: unknown;
            Output: unknown;
        };
        Date: {
            Input: Date;
            Output: Date;
        };
    };
}>>>(opts: {
    name: string;
} & PothosSchemaTypes.EnumTypeOptions<PothosSchemaTypes.ExtendDefaultTypes<{
    Context: {
        request: Request;
        params: GraphQLParams;
    } & UserContext;
    AuthScopes: Scopes;
    DefaultFieldNullability: true;
    Scalars: {
        JSON: {
            Input: unknown;
            Output: unknown;
        };
        Date: {
            Input: Date;
            Output: Date;
        };
    };
}>, Values>) => EnumRef<ShapeFromEnumValues<PothosSchemaTypes.ExtendDefaultTypes<{
    Context: {
        request: Request;
        params: GraphQLParams;
    } & UserContext;
    AuthScopes: Scopes;
    DefaultFieldNullability: true;
    Scalars: {
        JSON: {
            Input: unknown;
            Output: unknown;
        };
        Date: {
            Input: Date;
            Output: Date;
        };
    };
}>, Values>>;
interface InputObjectTypeOptions<Types extends SchemaTypes = BuilderTypes, Fields extends InputFieldMap = InputFieldMap> {
    isOneOf?: boolean;
    fields: (t: InputFieldBuilder<Types, 'InputObject'>) => Fields;
    description?: string;
    extensions?: Readonly<Record<string, unknown>>;
}
/**
 * Creates a re-usable input-type that can be used in arguments to your fields.
 *
 * @example
 * ```ts
 * const Pagination = inputType({
 *   description: 'The default pagination input type, allowing you to specify a limit and offset',
 *   name: 'Pagination',
 *   fields: (t) => ({
 *     limit: t.int({ default: 10 }),
 *     offset: t.int({ default: 0 })
 *   })
 * })
 *
 * addQueryFields((t) => ({
 *   myList: t.list({
 *     args: input: t.arg({ type: Pagination })
 *   })
 * })
 * ```
 */
declare const inputType: <Fields extends InputFieldMap>(opts: {
    name: string;
} & InputObjectTypeOptions<PothosSchemaTypes.ExtendDefaultTypes<{
    Context: {
        request: Request;
        params: GraphQLParams;
    } & UserContext;
    AuthScopes: Scopes;
    DefaultFieldNullability: true;
    Scalars: {
        JSON: {
            Input: unknown;
            Output: unknown;
        };
        Date: {
            Input: Date;
            Output: Date;
        };
    };
}>, Fields>) => InputObjectRef<InputShapeFromFields<Fields>>;
/**
 * Creates an interface-type which can be used in the `interfaces` option of `object` and `node`.
 *
 * @example
 * ```ts
 * const NewInterface = interfaceType<Shape, Parent>({
 *   name: 'NewInterface',
 *   resolveType: (parent) => 'Launch',
 *   fields: (t) => ({
 *     name: t.string()
 *   }),
 * })
 * ```
 */
declare const interfaceType: (opts: Parameters<(typeof builder)['interfaceType']>['1'] & {
    name: string;
}) => _pothos_core_dts_refs_interface.default<unknown, unknown>;
/**
 * Creates a union of types, these can be used in fields and will then have to resolve to
 * one of the union types.
 *
 * @example
 * ```ts
 * const NewInterface = unionType({
 *   name: 'Resource',
 *   resolveType: (parent) => 'Engine',
 *   types: [Fuel, Engine]
 * })
 * ```
 */
declare const unionType: (opts: Parameters<(typeof builder)['unionType']>['1'] & {
    name: string;
}) => _pothos_core_dts_refs_union.default<any, any>;

export { AuthenticationError, BadRequestError, ForbiddenError, FuseError, GetContext, InitialContext, NotFoundError, Scopes, StellateOptions, UserContext, addMutationFields, addNodeFields, addObjectFields, addQueryFields, reducedBuilder as builder, defineAuthScopes, enumType, inputType, interfaceType, node, objectType, unionType };

• Optional

  type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;

• createClient

  declare const createClient: (opts: Optional<ClientOptions, "exchanges">) => Client;

import { ClientOptions, Client } from 'urql';
export * from 'urql';
import { Exchange } from '@urql/core';

declare const cacheExchange: Exchange;

type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
declare const createClient: (opts: Optional<ClientOptions, 'exchanges'>) => Client;

export { cacheExchange, createClient };

• createAPIRouteHandler

  declare function createAPIRouteHandler<AdditionalContext extends Record<string, unknown> = any>(options?: {
      context?: GetContext<AdditionalContext>;
      stellate?: StellateOptions;
  }): (request: Request, context: NextPageContext) => Response | Promise<Response>;

• createPagesRouteHandler

  declare function createPagesRouteHandler<AdditionalContext extends Record<string, unknown> = any>(options?: {
      context?: GetContext<AdditionalContext>;
      stellate?: StellateOptions;
  }): graphql_yoga.YogaServerInstance<{
      req: NextApiRequest;
      res: NextApiResponse;
  }, {}>;

import * as graphql_yoga from 'graphql-yoga';
import { GetContext } from 'fuse';
import { NextPageContext, NextApiRequest, NextApiResponse } from 'next';
import { StellateOptions } from '../utils/yoga-helpers.ts';

declare function createAPIRouteHandler<AdditionalContext extends Record<string, unknown> = any>(options?: {
    context?: GetContext<AdditionalContext>;
    stellate?: StellateOptions;
}): (request: Request, context: NextPageContext) => Response | Promise<Response>;
declare function createPagesRouteHandler<AdditionalContext extends Record<string, unknown> = any>(options?: {
    context?: GetContext<AdditionalContext>;
    stellate?: StellateOptions;
}): graphql_yoga.YogaServerInstance<{
    req: NextApiRequest;
    res: NextApiResponse;
}, {}>;

export { createAPIRouteHandler, createPagesRouteHandler };

• Optional

  type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;

• createClient

  export function createClient(opts: Optional<ClientOptions, "exchanges">): {
      client: Client;
      ssr: SSRExchange;
  };

// src/next/client.ts
import {
  useQuery,
  UrqlProvider,
  ClientOptions,
  SSRExchange,
  Client,
} from '@urql/next'
export * from 'urql'
export { UrqlProvider as Provider, useQuery }

type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>
export function createClient(opts: Optional<ClientOptions, 'exchanges'>): {
  client: Client
  ssr: SSRExchange
}

• initGraphQLClient

  declare function initGraphQLClient(clientOptions: ClientOptions): Client;

• withGraphQLClient

  declare function withGraphQLClient(getClientConfig: NextGraphQLClientConfig): <C extends NextPage<any> | typeof NextApp>(AppOrPage: C) => NextComponentType<NextUrqlContext, {}, WithGraphQLClientProps>;

• Optional

  type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;

• NextGraphQLClientConfig

  type NextGraphQLClientConfig = (ssrExchange: SSRExchange, ctx?: NextPageContext) => Optional<ClientOptions, "exchanges">;

• NextUrqlContext

  type NextUrqlContext = NextGraphQLAppContext | NextGraphQLPageContext;

• WithGraphQLClientProps

  interface WithGraphQLClientProps {
      urqlClient?: Client;
      pageProps: any;
      graphqlState?: SSRData;
      [key: string]: any;
  }

• NextGraphQLPageContext

  interface NextGraphQLPageContext extends NextPageContext {
      urqlClient: Client;
  }

• NextGraphQLAppContext

  interface NextGraphQLAppContext extends AppContext {
      urqlClient: Client;
  }

import { ClientOptions, Client, SSRExchange, SSRData } from 'urql';
export * from 'urql';
import { NextPage, NextComponentType, NextPageContext } from 'next';
import NextApp, { AppContext } from 'next/app';
import { Exchange } from '@urql/core';

declare const cacheExchange: Exchange;

declare function initGraphQLClient(clientOptions: ClientOptions): Client;
declare function withGraphQLClient(getClientConfig: NextGraphQLClientConfig): <C extends NextPage<any> | typeof NextApp>(AppOrPage: C) => NextComponentType<NextUrqlContext, {}, WithGraphQLClientProps>;
type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
type NextGraphQLClientConfig = (ssrExchange: SSRExchange, ctx?: NextPageContext) => Optional<ClientOptions, 'exchanges'>;
interface WithGraphQLClientProps {
    urqlClient?: Client;
    pageProps: any;
    graphqlState?: SSRData;
    [key: string]: any;
}
interface NextGraphQLPageContext extends NextPageContext {
    urqlClient: Client;
}
interface NextGraphQLAppContext extends AppContext {
    urqlClient: Client;
}
type NextUrqlContext = NextGraphQLAppContext | NextGraphQLPageContext;

export { NextGraphQLAppContext, NextGraphQLClientConfig, NextGraphQLPageContext, NextUrqlContext, WithGraphQLClientProps, cacheExchange, initGraphQLClient, withGraphQLClient };

• Options

  interface Options {
      port?: number;
      path?: string;
  }

• nextFusePlugin

  declare function nextFusePlugin(options?: Options): (nextConfig?: any) => any;

interface Options {
    port?: number;
    path?: string;
}
declare function nextFusePlugin(options?: Options): (nextConfig?: any) => any;

export { nextFusePlugin };

• Optional

  type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;

• createClient

  export function createClient(opts: Optional<ClientOptions, "exchanges">): Client;

• ___internal_execute

  export function __internal_execute<Data = any, Variables extends AnyVariables = AnyVariables>(request: GraphQLRequestParams<Data, Variables> & {
      context?: (params: GraphQLParams) => UserContext;
  }): Promise<ExecutionResult<Data>>;

// src/next/rsc.ts
import {
  Client,
  ClientOptions,
  AnyVariables,
  GraphQLRequestParams,
} from '@urql/core'
import { ExecutionResult } from 'graphql'
import { GraphQLParams } from 'graphql-yoga'
import { UserContext } from 'fuse'

export { registerUrql as registerClient } from '@urql/next/rsc'
export * from '@urql/core'

type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>
export function createClient(opts: Optional<ClientOptions, 'exchanges'>): Client

export function __internal_execute<
  Data = any,
  Variables extends AnyVariables = AnyVariables,
>(
  request: GraphQLRequestParams<Data, Variables> & {
    context?: (params: GraphQLParams) => UserContext
  },
): Promise<ExecutionResult<Data>>