houdini 2.0.0-next.9 → 2.0.1

package/build/runtime/lib/pagination.d.ts

@@ -1,27 +0,0 @@
-import type { SendParams } from '../client/documentStore';
-import type { CursorHandlers, FetchFn, GraphQLObject, GraphQLVariables, QueryArtifact, QueryResult, FetchParams } from './types';
-export declare function cursorHandlers<_Data extends GraphQLObject, _Input extends GraphQLVariables>({ artifact, fetchUpdate: parentFetchUpdate, fetch: parentFetch, getState, getVariables, getSession, }: {
-    artifact: QueryArtifact;
-    getState: () => _Data | null;
-    getVariables: () => NonNullable<_Input>;
-    getSession: () => Promise<App.Session>;
-    fetch: FetchFn<_Data, _Input>;
-    fetchUpdate: (arg: SendParams, updates: string[]) => ReturnType<FetchFn<_Data, _Input>>;
-}): CursorHandlers<_Data, _Input>;
-export declare function offsetHandlers<_Data extends GraphQLObject, _Input extends GraphQLVariables>({ artifact, storeName, getState, getVariables, fetch: parentFetch, fetchUpdate: parentFetchUpdate, getSession, }: {
-    artifact: QueryArtifact;
-    fetch: FetchFn<_Data, _Input>;
-    fetchUpdate: (arg: SendParams) => ReturnType<FetchFn<_Data, _Input>>;
-    storeName: string;
-    getState: () => _Data | null;
-    getVariables: () => _Input;
-    getSession: () => Promise<App.Session>;
-}): {
-    loadNextPage: ({ limit, offset, fetch, metadata, }?: {
-        limit?: number | undefined;
-        offset?: number | undefined;
-        fetch?: typeof fetch | undefined;
-        metadata?: {} | undefined;
-    }) => Promise<void>;
-    fetch(params?: FetchParams<_Input>): Promise<QueryResult<_Data, _Input>>;
-};

package/build/runtime/lib/scalars.d.ts

@@ -1,14 +0,0 @@
-import type { ConfigFile } from './config';
-import { type FragmentArtifact, type MutationArtifact, type QueryArtifact, type SubscriptionArtifact, type SubscriptionSelection } from './types';
-export declare function marshalSelection({ selection, data, }: {
-    selection: SubscriptionSelection;
-    data: any;
-}): {} | null | undefined;
-export declare function marshalInputs<T>({ artifact, input, config, rootType, }: {
-    artifact: QueryArtifact | MutationArtifact | SubscriptionArtifact | FragmentArtifact;
-    input: unknown;
-    rootType?: string;
-    config: ConfigFile;
-}): {} | null | undefined;
-export declare function isScalar(config: ConfigFile, type: string): boolean;
-export declare function parseScalar(config: ConfigFile, type: string, value?: string): string | number | boolean | undefined;

package/build/runtime/lib/selection.d.ts

@@ -1,2 +0,0 @@
-import type { SubscriptionSelection } from './types';
-export declare function getFieldsForType(selection: SubscriptionSelection, __typename: string | undefined | null, loading: boolean): Required<SubscriptionSelection>['fields'];

package/build/runtime/public/cache.d.ts

@@ -1,42 +0,0 @@
-import type { Cache as _Cache } from '../cache/cache';
-import { type QueryArtifact } from '../lib';
-import { ListCollection } from './list';
-import { Record } from './record';
-import type { ArgType, CacheTypeDef, IDFields, QueryInput, QueryList, QueryValue, TypeFieldNames, TypeNames, ValidLists } from './types';
-export declare class Cache<Def extends CacheTypeDef> {
-    _internal_unstable: _Cache;
-    constructor(cache: _Cache);
-    get<T extends TypeNames<Def>>(type: T, data: IDFields<Def, T>): Record<Def, T>;
-    get config(): import("../lib").ConfigFile;
-    list<Name extends ValidLists<Def>>(name: Name, { parentID, allLists }?: {
-        parentID?: string;
-        allLists?: boolean;
-    }): ListCollection<Def, Name>;
-    read<_Query extends {
-        artifact: QueryArtifact;
-    }>({ query, variables, }: {
-        query: _Query;
-        variables?: QueryInput<QueryList<Def>, _Query>;
-    }): {
-        data: QueryValue<QueryList<Def>, _Query> | null;
-        partial: boolean;
-    };
-    write<_Query extends {
-        artifact: QueryArtifact;
-    }>({ query, variables, data, }: {
-        query: _Query;
-        data: QueryValue<QueryList<Def>, _Query>;
-        variables?: QueryInput<QueryList<Def>, _Query>;
-    }): void;
-    /**
-     * Mark some elements of the cache stale.
-     */
-    markStale<_Type extends TypeNames<Def>, _Field extends TypeFieldNames<Def, _Type>>(type?: _Type, options?: {
-        field?: _Field;
-        when?: ArgType<Def, _Type, _Field>;
-    }): void;
-    /**
-     * Reset the entire cache by clearing all records and lists
-     */
-    reset(): void;
-}

package/build/runtime/public/index.d.ts

@@ -1 +0,0 @@
-export { Cache } from './cache';

package/build/runtime/public/list.d.ts

@@ -1,18 +0,0 @@
-import type { Cache } from './cache';
-import type { CacheTypeDef, ListType, ValidLists, ListFilters } from './types';
-export declare class ListCollection<Def extends CacheTypeDef, ListName extends ValidLists<Def>> {
-    #private;
-    constructor({ parentID, allLists, when, cache, name, }: {
-        name: ValidLists<Def>;
-        parentID?: string;
-        allLists?: boolean;
-        when?: ListFilters<Def, ListName>;
-        cache: Cache<Def>;
-    });
-    append(...records: ListType<Def, ListName>[]): void;
-    prepend(...records: ListType<Def, ListName>[]): void;
-    toggle(where: 'first' | 'last', ...records: ListType<Def, ListName>[]): void;
-    when(filter: ListFilters<Def, ListName>): ListCollection<Def, ListName>;
-    remove(...records: ListType<Def, ListName>[]): void;
-    [Symbol.iterator](): Generator<string, void, unknown>;
-}

package/build/runtime/public/record.d.ts

@@ -1,40 +0,0 @@
-import type { FragmentArtifact } from '../lib/types';
-import type { Cache } from './cache';
-import type { ArgType, CacheTypeDef, FragmentList, FragmentValue, FragmentVariables, TypeFieldNames, ValidTypes } from './types';
-export declare class Record<Def extends CacheTypeDef, Type extends ValidTypes<Def>> {
-    #private;
-    type: string;
-    idFields: {};
-    constructor({ cache, type, id, idFields, }: {
-        cache: Cache<Def>;
-        type: string;
-        idFields: {};
-        id: string;
-    });
-    read<_Fragment extends {
-        artifact: FragmentArtifact;
-    }>({ fragment, variables, }: {
-        fragment: _Fragment;
-        variables?: FragmentVariables<FragmentList<Def, Type>, _Fragment>;
-    }): {
-        data: FragmentValue<FragmentList<Def, Type>, _Fragment> | null;
-        partial: boolean;
-    };
-    write<_Fragment extends {
-        artifact: FragmentArtifact;
-    }, _Variable>(args: {
-        fragment: _Fragment;
-        data: FragmentValue<FragmentList<Def, Type>, _Fragment>;
-        variables?: FragmentVariables<FragmentList<Def, Type>, _Fragment>;
-        forceStale?: boolean;
-    }): void;
-    delete(): void;
-    /**
-     * Mark some elements of the record stale in the cache.
-     * @param field
-     * @param when
-     */
-    markStale<Field extends TypeFieldNames<Def, Type>>(field?: Field, { when, }?: {
-        when?: ArgType<Def, Type, Field>;
-    }): void;
-}

package/build/runtime/public/tests/test.d.ts

@@ -1,156 +0,0 @@
-import { type SubscriptionSelection, type FragmentArtifact, type QueryArtifact } from '../../lib';
-import { Cache } from '../cache';
-import type { Record } from '../record';
-export type CacheTypeDefTest = {
-    types: {
-        __ROOT__: {
-            idFields: {};
-            fragments: [];
-            fields: {
-                test: {
-                    type: number | null;
-                    args: never;
-                };
-                testDate: {
-                    type: Date;
-                    args: never;
-                };
-                viewer: {
-                    type: Record<CacheTypeDefTest, 'User'> | null;
-                    args: never;
-                };
-                pets: {
-                    type: (Record<CacheTypeDefTest, 'Cat'> | Record<CacheTypeDefTest, 'User'>)[];
-                    args: never;
-                };
-                listOfLists: {
-                    type: ((Record<CacheTypeDefTest, 'Cat'> | Record<CacheTypeDefTest, 'User'> | null | (null | Record<CacheTypeDefTest, 'User'>)[])[] | Record<CacheTypeDefTest, 'Cat'> | Record<CacheTypeDefTest, 'User'> | null)[];
-                    args: never;
-                };
-                users: {
-                    type: Record<CacheTypeDefTest, 'User'>[] | null;
-                    args: never;
-                };
-                pet: {
-                    type: Record<CacheTypeDefTest, 'Cat'> | Record<CacheTypeDefTest, 'User'>;
-                    args: never;
-                };
-            };
-        };
-        User: {
-            idFields: {
-                id: string;
-            };
-            fragments: [
-                [
-                    {
-                        artifact: FragmentArtifact;
-                    },
-                    {
-                        firstName: string;
-                    },
-                    {
-                        pattern: string;
-                    }
-                ]
-            ];
-            fields: {
-                firstName: {
-                    type: string;
-                    args: never;
-                };
-                parent: {
-                    type: Record<CacheTypeDefTest, 'User'>;
-                    args: never;
-                };
-                id: {
-                    type: string;
-                    args: never;
-                };
-                __typename: {
-                    type: string;
-                    args: never;
-                };
-            };
-        };
-        Cat: {
-            idFields: {
-                id: string;
-            };
-            fragments: [];
-            fields: {
-                name: {
-                    type: string | null;
-                    args: never;
-                };
-                parent: {
-                    type: Record<CacheTypeDefTest, 'User'> | null;
-                    args: never;
-                };
-                id: {
-                    type: string;
-                    args: never;
-                };
-                __typename: {
-                    type: string;
-                    args: never;
-                };
-            };
-        };
-        Ghost: {
-            idFields: {
-                id: string;
-            };
-            fragments: [];
-            fields: {
-                name: {
-                    type: string | null;
-                    args: never;
-                };
-                __typename: {
-                    type: string;
-                    args: never;
-                };
-            };
-        };
-    };
-    queries: [
-        [
-            {
-                artifact: QueryArtifact;
-            },
-            {
-                viewer: {
-                    id: string;
-                    firstName: string;
-                    __typename: string;
-                    parent: {
-                        id: string;
-                        firstName: string;
-                        __typename: string;
-                    };
-                };
-            },
-            any
-        ]
-    ];
-    lists: {
-        All_Pets: {
-            types: 'User' | 'Cat';
-            filters: never;
-        };
-        All_Users: {
-            types: 'User';
-            filters: {
-                foo?: string;
-            };
-        };
-    };
-};
-export declare const testCache: () => Cache<CacheTypeDefTest>;
-export declare const testFragment: (selection: SubscriptionSelection) => {
-    artifact: FragmentArtifact;
-};
-export declare const testQuery: (selection: SubscriptionSelection) => {
-    artifact: QueryArtifact;
-};

package/build/runtime/public/types.d.ts

@@ -1,62 +0,0 @@
-import type { Record } from './record';
-export type CacheTypeDef = {
-    types: {
-        [typeName: string]: {
-            idFields: {
-                [fieldName: string]: any;
-            };
-            fields: {
-                [fieldName: string]: {
-                    args: any;
-                    type: any;
-                };
-            };
-            fragments: [any, any, any][];
-        };
-    };
-    lists: {
-        [listName: string]: {
-            types: any;
-            filters: any;
-        };
-    };
-    queries: [any, any, any][];
-};
-export type ValidTypes<Def extends CacheTypeDef> = keyof Def['types'];
-export type TypeFields<Def extends CacheTypeDef, Type extends keyof Def['types']> = Def['types'][Type]['fields'];
-export type TypeFieldNames<Def extends CacheTypeDef, Type extends keyof Def['types']> = Extract<keyof TypeFields<Def, Type>, string>;
-export type TypeNames<Def extends CacheTypeDef> = Extract<Exclude<ValidTypes<Def>, '__ROOT__'>, string>;
-export type FragmentList<Def extends CacheTypeDef, Type extends ValidTypes<Def>> = Def['types'][Type]['fragments'];
-export type QueryList<Def extends CacheTypeDef> = Def['queries'];
-export type IDFields<Def extends CacheTypeDef, Type extends keyof Def['types']> = Def['types'][Type]['idFields'];
-export type ProxyUnion<Def extends CacheTypeDef, U> = U extends null ? null : U extends TypeNames<Def> ? Record<Def, U> : never;
-export type FieldType<Def extends CacheTypeDef, Type extends keyof Def['types'], Field extends keyof TypeFields<Def, Type>> = TypeFields<Def, Type>[Field]['type'];
-export type ArgType<Def extends CacheTypeDef, Type extends keyof Def['types'], Field extends keyof TypeFields<Def, Type>> = TypeFields<Def, Type>[Field]['args'];
-export type ValidLists<Def extends CacheTypeDef> = Extract<keyof Def['lists'], string>;
-export type ListFilters<Def extends CacheTypeDef, ListName extends ValidLists<Def>> = Def['lists'][ListName]['filters'] extends any ? {
-    must?: Def['lists'][ListName]['filters'];
-    must_not?: Def['lists'][ListName]['filters'];
-} : never;
-export type ListType<Def extends CacheTypeDef, Name extends ValidLists<Def>> = ProxyUnion<Def, Def['lists'][Name]['types']>;
-/**
- * Note on the `_Key extends _Target && _Target extends _Key` check:
- * Sometimes two queries might have a similar shape/inputs, e.g.:
- *
- * query Query1($userId: ID!) {    |    query Query2($userId: ID!) {
- *   user(id: $userId) {           |      user($id: $userId) {
- *     id                          |        id
- *     name                        |        name
- *   }                             |        birthDate
- * }                               |      }
- *                                 |    }
- *
- * To TypeScript, it would look like Query2's result would extend Query1's result.
- * But if Query2 was listed in front of Query1 in the queries array above, `_Key extends _Target` will evaluate to true,
- * causing it to return Query2's input/result types, while you were looking for Query1's input/result types.
- * The additional `_Target extends _Key` ensures that the two objects have exactly the same shape, at least prompting the
- * user for the correct fields.
- */
-export type FragmentVariables<_List, _Target> = _List extends [infer Head, ...infer Rest] ? Head extends [infer _Key, infer _Value, infer _Input] ? _Key extends _Target ? _Target extends _Key ? _Input : FragmentValue<Rest, _Target> : FragmentValue<Rest, _Target> : 'Encountered unknown fragment. Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).' : 'Encountered unknown fragment. Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).';
-export type FragmentValue<List, _Target> = List extends [infer Head, ...infer Rest] ? Head extends [infer _Key, infer _Value, infer _Input] ? _Key extends _Target ? _Target extends _Key ? _Value : FragmentValue<Rest, _Target> : FragmentValue<Rest, _Target> : 'Encountered unknown fragment. Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).' : 'Encountered unknown fragment. Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).';
-export type QueryValue<List, _Target> = List extends [infer Head, ...infer Rest] ? Head extends [infer _Key, infer _Value, infer _Input] ? _Key extends _Target ? _Target extends _Key ? _Value : QueryValue<Rest, _Target> : QueryValue<Rest, _Target> : 'Encountered unknown query.Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).' : 'Encountered unknown query.Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).';
-export type QueryInput<List, _Target> = List extends [infer Head, ...infer Rest] ? Head extends [infer _Key, infer _Value, infer _Input] ? _Key extends _Target ? _Target extends _Key ? _Input : QueryInput<Rest, _Target> : QueryInput<Rest, _Target> : 'Encountered unknown query.Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).' : 'Encountered unknown query.Please make sure your runtime is up to date (ie, `vite dev` or `vite build`).';

package/build/runtime/router/cookies.d.ts

@@ -1,41 +0,0 @@
-/*!
- * cookie
- * Copyright(c) 2012-2014 Roman Shtylman
- * Copyright(c) 2015 Douglas Christopher Wilson
- * MIT Licensed
- */
-/**
- * Parse a cookie header.
- *
- * Parse the given cookie header string into an object
- * The object has the various cookies as keys(names) => values
- *
- * @param {string} str
- * @param {object} [options]
- * @return {object}
- * @public
- */
-export declare function parse(str: string, options?: {
-    decode?: (val: string) => string;
-}): Record<string, string>;
-/**
- * Serialize data into a cookie header.
- *
- * Serialize the a name value pair into a cookie string suitable for
- * http headers. An optional options object specified cookie parameters.
- *
- * serialize('foo', 'bar', { httpOnly: true })
- *   => "foo=bar; httpOnly"
- *
- */
-export declare function serialize(name: string, val: string, options: {
-    encode?: boolean;
-    maxAge?: number;
-    domain?: string;
-    path?: string;
-    expires?: Date;
-    httpOnly?: boolean;
-    priority?: string | number;
-    secure?: boolean;
-    sameSite?: string | boolean;
-}): string;

package/build/runtime/router/jwt.d.ts

@@ -1,117 +0,0 @@
-type SubtleCryptoImportKeyAlgorithm = any;
-/**
- * @typedef JwtAlgorithm
- * @type {'ES256'|'ES384'|'ES512'|'HS256'|'HS384'|'HS512'|'RS256'|'RS384'|'RS512'}
- */
-export type JwtAlgorithm = 'ES256' | 'ES384' | 'ES512' | 'HS256' | 'HS384' | 'HS512' | 'RS256' | 'RS384' | 'RS512';
-/**
- * @typedef JwtAlgorithms
- */
-export interface JwtAlgorithms {
-    [key: string]: SubtleCryptoImportKeyAlgorithm;
-}
-/**
- * @typedef JwtHeader
- * @prop {string} [typ] Type
- */
-export interface JwtHeader {
-    /**
-     * Type (default: `"JWT"`)
-     *
-     * @default "JWT"
-     */
-    typ?: string;
-    [key: string]: any;
-}
-/**
- * @typedef JwtPayload
- * @prop {string} [iss] Issuer
- * @prop {string} [sub] Subject
- * @prop {string | string[]} [aud] Audience
- * @prop {string} [exp] Expiration Time
- * @prop {string} [nbf] Not Before
- * @prop {string} [iat] Issued At
- * @prop {string} [jti] JWT ID
- */
-export interface JwtPayload {
-    /** Issuer */
-    iss?: string;
-    /** Subject */
-    sub?: string;
-    /** Audience */
-    aud?: string | string[];
-    /** Expiration Time */
-    exp?: number;
-    /** Not Before */
-    nbf?: number;
-    /** Issued At */
-    iat?: number;
-    /** JWT ID */
-    jti?: string;
-    [key: string]: any;
-}
-/**
- * @typedef JwtOptions
- * @prop {JwtAlgorithm | string} algorithm
- */
-export interface JwtOptions {
-    algorithm?: JwtAlgorithm | string;
-}
-/**
- * @typedef JwtSignOptions
- * @extends JwtOptions
- * @prop {JwtHeader} [header]
- */
-export interface JwtSignOptions extends JwtOptions {
-    header?: JwtHeader;
-}
-/**
- * @typedef JwtVerifyOptions
- * @extends JwtOptions
- * @prop {boolean} [throwError=false] If `true` throw error if checks fail. (default: `false`)
- */
-export interface JwtVerifyOptions extends JwtOptions {
-    /**
-     * If `true` throw error if checks fail. (default: `false`)
-     *
-     * @default false
-     */
-    throwError?: boolean;
-}
-/**
- * @typedef JwtData
- * @prop {JwtHeader} header
- * @prop {JwtPayload} payload
- */
-export interface JwtData {
-    header: JwtHeader;
-    payload: JwtPayload;
-}
-/**
- * Signs a payload and returns the token
- *
- * @param {JwtPayload} payload The payload object. To use `nbf` (Not Before) and/or `exp` (Expiration Time) add `nbf` and/or `exp` to the payload.
- * @param {string | JsonWebKey} secret A string which is used to sign the payload.
- * @param {JwtSignOptions | JwtAlgorithm | string} [options={ algorithm: 'HS256', header: { typ: 'JWT' } }] The options object or the algorithm.
- * @throws {Error} If there's a validation issue.
- * @returns {Promise<string>} Returns token as a `string`.
- */
-export declare function encode(payload: JwtPayload, secret: string | JsonWebKey, options?: JwtSignOptions | JwtAlgorithm): Promise<string>;
-/**
- * Verifies the integrity of the token and returns a boolean value.
- *
- * @param {string} token The token string generated by `jwt.sign()`.
- * @param {string | JsonWebKey} secret The string which was used to sign the payload.
- * @param {JWTVerifyOptions | JWTAlgorithm} options The options object or the algorithm.
- * @throws {Error | string} Throws an error `string` if the token is invalid or an `Error-Object` if there's a validation issue.
- * @returns {Promise<boolean>} Returns `true` if signature, `nbf` (if set) and `exp` (if set) are valid, otherwise returns `false`.
- */
-export declare function verify(token: string, secret: string | JsonWebKey, options?: JwtVerifyOptions | JwtAlgorithm): Promise<boolean>;
-/**
- * Returns the payload **without** verifying the integrity of the token. Please use `jwt.verify()` first to keep your application secure!
- *
- * @param {string} token The token string generated by `jwt.sign()`.
- * @returns {JwtData} Returns an `object` containing `header` and `payload`.
- */
-export declare function decode(token: string): JwtData;
-export {};

package/build/runtime/router/server.d.ts

@@ -1,24 +0,0 @@
-import { createServerAdapter } from '@whatwg-node/server';
-import type { GraphQLSchema } from 'graphql';
-import type { HoudiniClient } from '../client';
-import { Server } from '../server';
-import type { RouterManifest, RouterPageManifest, YogaServerOptions } from './types';
-export declare function _serverHandler<ComponentType = unknown>({ schema, server, client, production, manifest, graphqlEndpoint, on_render, componentCache, }: {
-    schema?: GraphQLSchema | null;
-    server?: Server<any, any>;
-    client: HoudiniClient;
-    production: boolean;
-    manifest: RouterManifest<ComponentType> | null;
-    assetPrefix: string;
-    graphqlEndpoint: string;
-    componentCache: Record<string, any>;
-    on_render: (args: {
-        url: string;
-        match: RouterPageManifest<ComponentType> | null;
-        manifest: RouterManifest<unknown>;
-        session: App.Session;
-        componentCache: Record<string, any>;
-    }) => Response | Promise<Response | undefined> | undefined;
-} & Omit<YogaServerOptions, 'schema'>): (request: Request) => Promise<Response>;
-export declare const serverAdapterFactory: (args: Parameters<typeof _serverHandler>[0]) => ReturnType<typeof createServerAdapter>;
-export type ServerAdapterFactory = typeof serverAdapterFactory;

package/build/runtime/router/types.d.ts

@@ -1,26 +0,0 @@
-import type { QueryArtifact } from '$houdini/runtime/lib/types';
-import type { createYoga } from 'graphql-yoga';
-import type { RouteParam } from './match';
-export type YogaServer = ReturnType<typeof createYoga>;
-export type YogaServerOptions = Parameters<typeof createYoga>[0];
-export type RouterManifest<_ComponentType> = {
-    pages: Record<string, RouterPageManifest<_ComponentType>>;
-};
-export type { ServerAdapterFactory } from './server';
-export type RouterPageManifest<_ComponentType> = {
-    id: string;
-    pattern: RegExp;
-    params: RouteParam[];
-    documents: Record<string, {
-        artifact: () => Promise<{
-            default: QueryArtifact;
-        }>;
-        loading: boolean;
-        variables: Record<string, {
-            type: string;
-        }>;
-    }>;
-    component: () => Promise<{
-        default: _ComponentType;
-    }>;
-};

package/build/runtime/server/index.d.ts

@@ -1,17 +0,0 @@
-import type { ServerAdapterRequestHandler } from '@whatwg-node/server';
-import { YogaServer } from 'graphql-yoga';
-import type { YogaSchemaDefinition } from 'graphql-yoga/typings/plugins/use-schema';
-type YogaParams = Required<ConstructorParameters<typeof YogaServer>>[0];
-type ConstructorParams = Omit<YogaParams, 'schema' | 'graphqlEndpoint'>;
-export declare class Server<ServerContext extends Record<string, any>, UserContext extends Record<string, any>> {
-    opts: ConstructorParams | null;
-    _yoga: YogaServer<any, any> | null;
-    constructor(opts?: ConstructorParams);
-    init({ endpoint, schema, getSession, }: {
-        schema: YogaSchemaDefinition<any>;
-        endpoint: string;
-        getSession: (request: Request) => Promise<UserContext>;
-    }): import("@whatwg-node/server").ServerAdapter<ServerContext, Server<ServerContext, UserContext>>;
-    handle: ServerAdapterRequestHandler<ServerContext>;
-}
-export {};