@avantstay/graphql-ts-client 10.5.1 → 10.6.0

package/dist/endpoint.d.ts

@@ -1,13 +1,13 @@
-import { C as ClientConfig, I as IResponseListener, E as Endpoint } from './types-85e628f6.js';
+import { C as ClientConfig, I as IResponseListener, E as Endpoint } from './types-4ecbabdf.js';
 
-declare const getApiEndpointCreator: (apiConfig: {
-    getClient: () => ClientConfig;
-    responseListeners: IResponseListener[];
-    typesTree: any;
-    maxAge: number;
-    verbose: boolean;
-    formatGraphQL: any;
-    errorsParser?: ((errors: any[]) => any) | undefined;
+declare const getApiEndpointCreator: (apiConfig: {
+    getClient: () => ClientConfig;
+    responseListeners: IResponseListener[];
+    typesTree: any;
+    maxAge: number;
+    verbose: boolean;
+    formatGraphQL: any;
+    errorsParser?: ((errors: any[]) => any) | undefined;
 }) => <I = any, O = any, E = any>(kind: 'mutation' | 'query', queryName: string) => Endpoint<I, O, E>;
 
 export { getApiEndpointCreator };

package/dist/index.d.ts

@@ -1,22 +1,24 @@
 import { PathLike } from 'fs';
-export { C as ClientConfig, c as DeepReplace, D as Defined, E as Endpoint, G as GraphQLClientError, I as IResponseListener, J as JsonOutput, L as LogInfo, M as Maybe, P as Projection, d as RawEndpoint, b as Replacement, R as ResponseData, a as ResponseListenerInfo, U as Unpacked } from './types-85e628f6.js';
+export { C as ClientConfig, c as DeepReplace, D as Defined, E as Endpoint, G as GraphQLClientError, I as IResponseListener, J as JsonOutput, L as LogInfo, M as Maybe, P as Projection, d as RawEndpoint, b as Replacement, R as ResponseData, a as ResponseListenerInfo, U as Unpacked } from './types-4ecbabdf.js';
 
-type IClientOptions = {
-    output?: PathLike;
-    clientName?: string;
-    headers?: {
-        [key: string]: string;
-    };
-    introspectionEndpoint?: string;
-    endpoint: string;
-    verbose?: boolean;
-    formatGraphQL?: boolean;
-    skipCache?: boolean;
-    errorsParser?: (errors: any[]) => any;
-};
-declare function generateTypescriptClient({ introspectionEndpoint, output, ...options }: IClientOptions): Promise<{
-    typings: string;
-    js: string;
-}>;
+type IClientOptions = {
+    output?: PathLike;
+    clientName?: string;
+    headers?: {
+        [key: string]: string;
+    };
+    introspectionEndpoint?: string;
+    endpoint: string;
+    verbose?: boolean;
+    formatGraphQL?: boolean;
+    skipCache?: boolean;
+    errorsParser?: (errors: any[]) => any;
+};
+type Client = {
+    typings: string;
+    js: string;
+};
+declare function generateTypescriptClient({ introspectionEndpoint, ...options }: IClientOptions): Promise<Client>;
+declare function generateTypescriptClientFromSDL(SDL: string, options: IClientOptions): Client;
 
-export { generateTypescriptClient };
+export { generateTypescriptClient, generateTypescriptClientFromSDL };

package/dist/index.js

@@ -464,6 +464,9 @@ __export(src_exports, {
     },
     generateTypescriptClient: function() {
         return generateTypescriptClient;
+    },
+    generateTypescriptClientFromSDL: function() {
+        return generateTypescriptClientFromSDL;
     }
 });
 module.exports = __toCommonJS(src_exports);
@@ -484,7 +487,7 @@ var prettier = __toESM(require("prettier"));
 // package.json
 var package_default = {
     name: "@avantstay/graphql-ts-client",
-    version: "10.5.1",
+    version: "10.6.0",
     description: "GraphQL Typescript Client Generator",
     author: "Wellington Guimaraes",
     license: "MIT",
@@ -570,6 +573,9 @@ var package_default = {
         tslib: "^2.3.1",
         tsup: "^6.5.0",
         typescript: "^4.9.4"
+    },
+    publishConfig: {
+        "@avantstay:registry": "https://registry.npmjs.org/"
     }
 };
 // src/generateTypescriptClient.ts
@@ -906,19 +912,43 @@ function _fetchIntrospection() {
     });
     return _fetchIntrospection.apply(this, arguments);
 }
+function generateClient(introspectionTypes, _param) {
+    var output = _param.output, restOptions = _objectWithoutProperties(_param, [
+        "output"
+    ]);
+    var _generateClientCode = generateClientCode(introspectionTypes, restOptions), js = _generateClientCode.js, typings = _generateClientCode.typings;
+    if (output && typeof output === "string") {
+        var outputDir = import_path.default.dirname(output);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, {
+                recursive: true
+            });
+        }
+        fs.writeFileSync(output.replace(/(\.(ts|js))?$/, ".d.ts"), typings, {
+            encoding: "utf8"
+        });
+        fs.writeFileSync(output.replace(/(\.(ts|js))?$/, ".js"), js, {
+            encoding: "utf8"
+        });
+    }
+    return {
+        js: js,
+        typings: typings
+    };
+}
 function generateTypescriptClient(_param) {
     return _generateTypescriptClient.apply(this, arguments);
 }
 function _generateTypescriptClient() {
     _generateTypescriptClient = _asyncToGenerator(function(_param) {
-        var introspectionEndpoint, output, options, types, _generateClientCode, js, typings, outputDir;
+        var introspectionEndpoint, options, _options_clientName, introspectionTypes;
         return __generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    introspectionEndpoint = _param.introspectionEndpoint, output = _param.output, options = _objectWithoutProperties(_param, [
-                        "introspectionEndpoint",
-                        "output"
+                    introspectionEndpoint = _param.introspectionEndpoint, options = _objectWithoutProperties(_param, [
+                        "introspectionEndpoint"
                     ]);
+                    console.log("Generating TypeScript client (name: ".concat((_options_clientName = options.clientName) !== null && _options_clientName !== void 0 ? _options_clientName : "n/a", ")"));
                     (0, import_axios_retry.default)(import_axios.default, {
                         retries: 5,
                         retryDelay: function(retryCount) {
@@ -932,34 +962,24 @@ function _generateTypescriptClient() {
                         }))
                     ];
                 case 1:
-                    types = _state.sent();
-                    _generateClientCode = generateClientCode(types, options), js = _generateClientCode.js, typings = _generateClientCode.typings;
-                    if (output && typeof output === "string") {
-                        outputDir = import_path.default.dirname(output);
-                        if (!fs.existsSync(outputDir)) {
-                            fs.mkdirSync(outputDir, {
-                                recursive: true
-                            });
-                        }
-                        fs.writeFileSync(output.replace(/(\.(ts|js))?$/, ".d.ts"), typings, {
-                            encoding: "utf8"
-                        });
-                        fs.writeFileSync(output.replace(/(\.(ts|js))?$/, ".js"), js, {
-                            encoding: "utf8"
-                        });
-                    }
+                    introspectionTypes = _state.sent();
                     return [
                         2,
-                        {
-                            js: js,
-                            typings: typings
-                        }
+                        generateClient(introspectionTypes, options)
                     ];
             }
         });
     });
     return _generateTypescriptClient.apply(this, arguments);
 }
+function generateTypescriptClientFromSDL(SDL, options) {
+    var _data;
+    var _options_clientName;
+    console.log("Generating TypeScript client from SDL (name: ".concat((_options_clientName = options.clientName) !== null && _options_clientName !== void 0 ? _options_clientName : "n/a", ")"));
+    var graphqlSchemaObj = (0, import_graphql.buildSchema)(SDL);
+    var introspectionTypes = (_data = (0, import_graphql.graphqlSync)(graphqlSchemaObj, new import_graphql.Source((0, import_graphql.getIntrospectionQuery)())).data) === null || _data === void 0 ? void 0 : _data.__schema.types;
+    return generateClient(introspectionTypes, options);
+}
 // src/types.ts
 var GraphQLClientError = /*#__PURE__*/ function(Error1) {
     _inherits(GraphQLClientError1, Error1);
@@ -993,5 +1013,6 @@ var GraphQLClientError = /*#__PURE__*/ function(Error1) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
     GraphQLClientError: GraphQLClientError,
-    generateTypescriptClient: generateTypescriptClient
+    generateTypescriptClient: generateTypescriptClient,
+    generateTypescriptClientFromSDL: generateTypescriptClientFromSDL
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avantstay/graphql-ts-client",
-  "version": "10.5.1",
+  "version": "10.6.0",
   "description": "GraphQL Typescript Client Generator",
   "author": "Wellington Guimaraes",
   "license": "MIT",
@@ -8,8 +8,8 @@
   "typings": "dist/index.d.ts",
   "scripts": {
     "build": "tsup src/index.ts src/endpoint.ts --dts",
-    "test": "cross-env GQL_CLIENT_DIST_PATH='.' jest --watch",
-    "prepublishOnly": "yarn build"
+    "test": "cross-env GQL_CLIENT_DIST_PATH='.' jest --watch"
+
   },
   "files": [
     "dist",
@@ -86,5 +86,8 @@
     "tslib": "^2.3.1",
     "tsup": "^6.5.0",
     "typescript": "^4.9.4"
+  },
+  "publishConfig": {
+    "@avantstay:registry": "https://registry.npmjs.org/"
   }
 }

package/src/__snapshots__/generateTypescriptClient.test.ts.snap

@@ -0,0 +1,133 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Generated Client should generate proper code from SDL 1`] = `
+{
+  "js": "var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  client: () => client,
+  default: () => stdin_default
+});
+var import_endpoint = __toModule(require("../dist/endpoint"));
+const formatGraphQL = (query) => query;
+const typesTree = {};
+let verbose = false;
+let headers = {};
+let url = "https://sample.endpoint.com/graphl";
+let retryConfig = {
+  max: 0,
+  before: void 0,
+  waitBeforeRetry: 0
+};
+let responseListeners = [];
+let errorsParser = void 0;
+let apiEndpoint = (0, import_endpoint.getApiEndpointCreator)({
+  getClient: () => ({ url, headers, retryConfig }),
+  responseListeners,
+  maxAge: 3e4,
+  verbose,
+  typesTree,
+  formatGraphQL,
+  errorsParser
+});
+const client = {
+  addResponseListener: (listener) => responseListeners.push(listener),
+  setHeader: (key, value) => {
+    headers[key] = value;
+  },
+  setHeaders: (newHeaders) => {
+    headers = newHeaders;
+  },
+  setRetryConfig: (options) => {
+    if (!Number.isInteger(options.max) || options.max < 0) {
+      throw new Error("retryOptions.max should be a non-negative integer");
+    }
+    retryConfig = {
+      max: options.max,
+      waitBeforeRetry: options.waitBeforeRetry,
+      before: options.before
+    };
+  },
+  setUrl: (_url) => url = _url,
+  queries: {
+    hello: apiEndpoint("query", "hello")
+  },
+  mutations: {}
+};
+var stdin_default = client;
+",
+  "typings": "// noinspection TypeScriptUnresolvedVariable, ES6UnusedImports, JSUnusedLocalSymbols, TypeScriptCheckImport
+import { DeepRequired } from "ts-essentials"
+import { Maybe, IResponseListener, Endpoint } from "../dist"
+
+// Scalars
+export type IDate = string | Date
+
+// Enums
+
+type AllEnums = never
+
+// Args
+export interface HelloArgs {}
+
+// Input/Output Types
+
+/**
+ * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
+ */
+
+export interface Query {
+  hello?: string
+}
+
+// Selection Types
+
+export declare const client: {
+  addResponseListener: (listener: IResponseListener) => void
+  setHeader: (key: string, value: string) => void
+  setHeaders: (newHeaders: { [k: string]: string }) => void
+  setUrl: (url: string) => void
+  setRetryConfig: (options: {
+    max: number
+    waitBeforeRetry?: number
+    before?: IResponseListener
+  }) => void
+  queries: {
+    hello: Endpoint<
+      {
+        __headers?: { [key: string]: string }
+        __retry?: boolean
+        __alias?: string
+      },
+      string,
+      AllEnums
+    >
+  }
+  mutations: {}
+}
+
+export default client
+",
+}
+`;

package/src/__testClient.d.ts

@@ -1,6 +1,6 @@
 // noinspection TypeScriptUnresolvedVariable, ES6UnusedImports, JSUnusedLocalSymbols, TypeScriptCheckImport
 import { DeepRequired } from "ts-essentials"
-import { Maybe, IResponseListener, Endpoint } from "."
+import { Maybe, IResponseListener, Endpoint } from "../dist"
 
 // Scalars
 export type IDate = string | Date

package/src/__testClient.js

@@ -4,37 +4,31 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
 var __export = (target, all) => {
+  __markAsModule(target);
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
   }
-  return to;
+  return target;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var stdin_exports = {};
-__export(stdin_exports, {
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
   BookType: () => BookType,
   default: () => stdin_default,
   myApiClient: () => myApiClient
 });
-module.exports = __toCommonJS(stdin_exports);
-var import_endpoint = require("./endpoint");
-var import_standalone = require("prettier/standalone");
-var import_parser_graphql = __toESM(require("prettier/parser-graphql"));
+var import_endpoint = __toModule(require("../dist/endpoint"));
+var import_standalone = __toModule(require("prettier/standalone"));
+var import_parser_graphql = __toModule(require("prettier/parser-graphql"));
 const formatGraphQL = (query) => (0, import_standalone.format)(query, { parser: "graphql", plugins: [import_parser_graphql.default] });
 const BookType = {
   dolor: "DOLOR",
@@ -87,9 +81,7 @@ let apiEndpoint = (0, import_endpoint.getApiEndpointCreator)({
   errorsParser
 });
 const myApiClient = {
-  addResponseListener: (listener) => responseListeners.push(
-    listener
-  ),
+  addResponseListener: (listener) => responseListeners.push(listener),
   setHeader: (key, value) => {
     headers[key] = value;
   },

package/src/generateTypescriptClient.test.ts

@@ -1,6 +1,6 @@
 import { ApolloServer } from 'apollo-server'
 import * as path from 'path'
-import { generateTypescriptClient } from './generateTypescriptClient'
+import { generateTypescriptClient, generateTypescriptClientFromSDL } from './generateTypescriptClient'
 import { startServer } from './testServer'
 import { GraphQLClientError, ResponseListenerInfo } from './types'
 
@@ -124,4 +124,13 @@ describe('Generated Client', () => {
     expect(responseData?.queryName).toBe('failingQuery')
     expect(responseData?.response.errors.length).toBeGreaterThan(0)
   })
+
+  it('should generate proper code from SDL', ()=>{
+    const sdlString = `
+  type Query {
+    hello: String
+  }
+`;
+    expect(generateTypescriptClientFromSDL(sdlString, {endpoint: 'https://sample.endpoint.com/graphl'})).toMatchSnapshot()
+  })
 })

package/src/generateTypescriptClient.ts

@@ -5,6 +5,8 @@ import * as esbuild from 'esbuild'
 import * as fs from 'fs'
 import { PathLike } from 'fs'
 import {
+  buildSchema,
+  graphqlSync,
   getIntrospectionQuery,
   IntrospectionEnumType,
   IntrospectionField,
@@ -13,6 +15,7 @@ import {
   IntrospectionObjectType,
   IntrospectionOutputTypeRef,
   IntrospectionType,
+  Source,
 } from 'graphql'
 import { kebabCase } from 'lodash'
 import orderBy from 'lodash/orderBy'
@@ -479,7 +482,7 @@ function generateClientCode(types: ReadonlyArray<IntrospectionType>, options: Om
   return output
 }
 
-async function fetchIntrospection({ endpoint, headers }: FetchIntrospectionOptions) {
+async function fetchIntrospection({ endpoint, headers }: FetchIntrospectionOptions): Promise<ReadonlyArray<IntrospectionType>> {
   const introspectionCacheFileName = `gql-ts-client__introspection__${kebabCase(endpoint)}.json`
   const introspectionCacheFilePath = path.resolve(tempDir, introspectionCacheFileName)
 
@@ -522,15 +525,10 @@ async function fetchIntrospection({ endpoint, headers }: FetchIntrospectionOptio
   return types
 }
 
-export async function generateTypescriptClient({ introspectionEndpoint, output, ...options }: IClientOptions): Promise<{ typings: string; js: string }> {
-  axiosRetry(axios, { retries: 5, retryDelay: retryCount => 1000 * 2 ** retryCount })
-
-  const types = await fetchIntrospection({
-    ...options,
-    endpoint: introspectionEndpoint || options.endpoint,
-  })
+type Client = { typings: string; js: string }
 
-  const { js, typings } = generateClientCode(types, options)
+function generateClient(introspectionTypes: ReadonlyArray<IntrospectionType>, {output,...restOptions}: IClientOptions): Client {
+  const { js, typings } = generateClientCode(introspectionTypes, restOptions)
 
   if (output && typeof output === 'string') {
     const outputDir = path.dirname(output)
@@ -545,3 +543,26 @@ export async function generateTypescriptClient({ introspectionEndpoint, output,
 
   return { js, typings }
 }
+
+export async function generateTypescriptClient({ introspectionEndpoint, ...options }: IClientOptions): Promise<Client> {
+  console.log(`Generating TypeScript client (name: ${options.clientName ?? 'n/a'})`)
+
+  axiosRetry(axios, { retries: 5, retryDelay: retryCount => 1000 * 2 ** retryCount })
+
+  const introspectionTypes = await fetchIntrospection({
+    ...options,
+    endpoint: introspectionEndpoint || options.endpoint,
+  })
+
+  return generateClient(introspectionTypes, options)
+
+}
+
+export function generateTypescriptClientFromSDL(SDL: string, options: IClientOptions): Client {
+  console.log(`Generating TypeScript client from SDL (name: ${options.clientName ?? 'n/a'})`);
+
+  const graphqlSchemaObj = buildSchema(SDL);
+  const introspectionTypes = graphqlSync(graphqlSchemaObj, new Source(getIntrospectionQuery())).data?.__schema.types as IntrospectionType[]
+
+  return generateClient(introspectionTypes, options)
+}

package/src/index.ts

@@ -1,3 +1,3 @@
-export { generateTypescriptClient } from './generateTypescriptClient'
+export { generateTypescriptClient, generateTypescriptClientFromSDL } from './generateTypescriptClient'
 
 export * from './types'

package/dist/types-85e628f6.d.ts

@@ -1,69 +0,0 @@
-type Maybe<T> = null | undefined | T;
-type Defined<T> = Exclude<T, undefined>;
-type ResponseData = {
-    data: any;
-    warnings: any;
-    headers: any;
-    status?: number;
-    errors: {
-        message: string;
-    }[];
-};
-type ResponseListenerInfo = {
-    queryName: string;
-    query: string;
-    variables: any;
-    response: ResponseData;
-};
-type IResponseListener = (info: ResponseListenerInfo) => void | Promise<void>;
-type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
-type Projection<Selection, Base, E = never> = Base extends Array<any> ? ArrayElement<Base> extends Date | string | number | boolean | null | undefined | E ? ArrayElement<Base>[] : Projection<Defined<Selection>, ArrayElement<Base>, E>[] : Base extends Date | string | number | boolean | null | E ? Selection extends undefined ? Base | undefined : Base : {
-    [k in keyof Selection & keyof Base]: Selection[k] extends boolean ? Base[k] : Base[k] extends Array<infer A> ? Projection<Defined<Selection[k]>, A, E>[] : Projection<Defined<Selection[k]>, Base[k], E>;
-};
-type Unpacked<T> = T extends (infer U)[] ? U : T extends (...args: any[]) => infer U ? U : T extends Promise<infer U> ? U : T;
-type Replacement<M extends [any, any], T> = M extends any ? ([T] extends [M[0]] ? M[1] : never) : never;
-type DeepReplace<T, Ignore, M extends [any, any]> = {
-    [P in keyof T]: T[P] extends M[0] ? T[P] extends Ignore ? T[P] extends object ? DeepReplace<T[P], Ignore, M> : T[P] : Replacement<M, T[P]> : T[P] extends object ? DeepReplace<T[P], Ignore, M> : T[P];
-};
-type RawEndpoint<I, O, E> = <S extends I>(jsonQuery?: S) => Promise<{
-    data: Projection<S, O, E>;
-    errors: any[];
-    warnings: any[];
-    headers: any;
-    status: any;
-}>;
-type JsonOutput<O, ToBeIgnored> = DeepReplace<O, ToBeIgnored, [string | Date, string]>;
-type Endpoint<I, O, E> = (<S extends I>(jsonQuery?: S) => Promise<Projection<S, JsonOutput<O, E>, E>>) & {
-    memo: <S extends I>(jsonQuery?: S) => Promise<Projection<S, JsonOutput<O, E>, E>>;
-    memoRaw: RawEndpoint<I, JsonOutput<O, E>, E>;
-    raw: RawEndpoint<I, JsonOutput<O, E>, E>;
-};
-type ClientConfig = {
-    url: string;
-    headers: {
-        [key: string]: string;
-    };
-    retryConfig: {
-        max: number;
-        waitBeforeRetry?: number;
-        before: IResponseListener;
-    };
-};
-type LogInfo = {
-    query: string;
-    variables: any;
-    formatGraphQL: any;
-    kind: string;
-    queryName: string;
-    response?: any;
-    error?: Error;
-    duration: number;
-};
-declare class GraphQLClientError extends Error {
-    responseData: ResponseData;
-    constructor(responseData: ResponseData);
-    get message(): string;
-    get response(): ResponseData;
-}
-
-export { ClientConfig as C, Defined as D, Endpoint as E, GraphQLClientError as G, IResponseListener as I, JsonOutput as J, LogInfo as L, Maybe as M, Projection as P, ResponseData as R, Unpacked as U, ResponseListenerInfo as a, Replacement as b, DeepReplace as c, RawEndpoint as d };