@aws-amplify/api-graphql 4.0.1-api-v6-models.9351bcf.0 → 4.0.1-api-v6-models.891fe0d.0

package/lib-esm/internals/generateModelsProperty.js

@@ -1,327 +1,34 @@
-import { __assign, __awaiter, __generator, __read, __spreadArray, __values } from "tslib";
-import { initializeModel, generateGraphQLDocument, buildGraphQLVariables, graphQLOperationsInfo, flattenItems, } from './APIClient';
-import { __authMode, __authToken, } from '../types';
-import { findIndexByFields, resolvePKFields } from '../utils';
-import { Observable, map } from 'rxjs';
-/**
- * Produces a parameter object that can contains auth mode/token overrides
- * only if present in either `options` (first) or configured on the `client`
- * as a fallback.
- *
- * @param client Configured client from `generateClient`
- * @param options Args/Options obect from call site.
- * @returns
- */
-function authModeParams(client, options) {
-    if (options === void 0) { options = {}; }
-    return {
-        authMode: options.authMode || client[__authMode],
-        authToken: options.authToken || client[__authToken],
-    };
-}
+import { graphQLOperationsInfo } from './APIClient';
+import { listFactory } from './operations/list';
+import { getFactory } from './operations/get';
+import { subscriptionFactory } from './operations/subscription';
+import { observeQueryFactory } from './operations/observeQuery';
 export function generateModelsProperty(client, params) {
-    var e_1, _a;
-    var _this = this;
-    var _b, _c;
-    var models = {};
-    var config = params.amplify.getConfig();
-    var modelIntrospection = (_c = (_b = config.API) === null || _b === void 0 ? void 0 : _b.GraphQL) === null || _c === void 0 ? void 0 : _c.modelIntrospection;
+    const models = {};
+    const config = params.amplify.getConfig();
+    const modelIntrospection = config.API?.GraphQL?.modelIntrospection;
     if (!modelIntrospection) {
         return {};
     }
-    var _loop_1 = function (model) {
-        var name_1 = model.name;
-        models[name_1] = {};
-        Object.entries(graphQLOperationsInfo).forEach(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], operationPrefix = _b[1].operationPrefix;
-            var operation = key;
+    const SUBSCRIPTION_OPS = ['ONCREATE', 'ONUPDATE', 'ONDELETE'];
+    for (const model of Object.values(modelIntrospection.models)) {
+        const { name } = model;
+        models[name] = {};
+        Object.entries(graphQLOperationsInfo).forEach(([key, { operationPrefix }]) => {
+            const operation = key;
             if (operation === 'LIST') {
-                models[name_1][operationPrefix] = function (args) { return __awaiter(_this, void 0, void 0, function () {
-                    var query, variables, auth, _a, data, extensions, _b, key_1, flattenedResult, initialized, error_1;
-                    return __generator(this, function (_c) {
-                        switch (_c.label) {
-                            case 0:
-                                query = generateGraphQLDocument(modelIntrospection.models, name_1, 'LIST', args);
-                                variables = buildGraphQLVariables(model, 'LIST', args, modelIntrospection);
-                                _c.label = 1;
-                            case 1:
-                                _c.trys.push([1, 3, , 4]);
-                                auth = authModeParams(client, args);
-                                return [4 /*yield*/, client.graphql(__assign(__assign({}, auth), { query: query, variables: variables }))];
-                            case 2:
-                                _a = (_c.sent()), data = _a.data, extensions = _a.extensions;
-                                // flatten response
-                                if (data !== undefined) {
-                                    _b = __read(Object.keys(data), 1), key_1 = _b[0];
-                                    if (data[key_1].items) {
-                                        flattenedResult = flattenItems(data)[key_1];
-                                        // don't init if custom selection set
-                                        if (args === null || args === void 0 ? void 0 : args.selectionSet) {
-                                            return [2 /*return*/, {
-                                                    data: flattenedResult,
-                                                    nextToken: data[key_1].nextToken,
-                                                    extensions: extensions,
-                                                }];
-                                        }
-                                        else {
-                                            initialized = initializeModel(client, name_1, flattenedResult, modelIntrospection, auth.authMode, auth.authToken);
-                                            return [2 /*return*/, {
-                                                    data: initialized,
-                                                    nextToken: data[key_1].nextToken,
-                                                    extensions: extensions,
-                                                }];
-                                        }
-                                    }
-                                    return [2 /*return*/, {
-                                            data: data[key_1],
-                                            nextToken: data[key_1].nextToken,
-                                            extensions: extensions,
-                                        }];
-                                }
-                                return [3 /*break*/, 4];
-                            case 3:
-                                error_1 = _c.sent();
-                                if (error_1.errors) {
-                                    // graphql errors pass through
-                                    return [2 /*return*/, error_1];
-                                }
-                                else {
-                                    // non-graphql errors re re-thrown
-                                    throw error_1;
-                                }
-                                return [3 /*break*/, 4];
-                            case 4: return [2 /*return*/];
-                        }
-                    });
-                }); };
+                models[name][operationPrefix] = listFactory(client, modelIntrospection, model);
             }
-            else if (['ONCREATE', 'ONUPDATE', 'ONDELETE'].includes(operation)) {
-                models[name_1][operationPrefix] = function (args) {
-                    var query = generateGraphQLDocument(modelIntrospection.models, name_1, operation);
-                    var variables = buildGraphQLVariables(model, operation, args, modelIntrospection);
-                    var auth = authModeParams(client, args);
-                    var observable = client.graphql(__assign(__assign({}, auth), { query: query, variables: variables }));
-                    return observable.pipe(map(function (value) {
-                        var _a = __read(Object.keys(value.data), 1), key = _a[0];
-                        var _b = __read(initializeModel(client, name_1, [value.data[key]], modelIntrospection, auth.authMode, auth.authToken), 1), initialized = _b[0];
-                        return initialized;
-                    }));
-                };
+            else if (SUBSCRIPTION_OPS.includes(operation)) {
+                models[name][operationPrefix] = subscriptionFactory(client, modelIntrospection, model, operation);
             }
             else if (operation === 'OBSERVE_QUERY') {
-                models[name_1][operationPrefix] = function (arg) {
-                    return new Observable(function (subscriber) {
-                        // what we'll be sending to our subscribers
-                        var items = [];
-                        // To enqueue subscription messages while we collect our initial
-                        // result set.
-                        var messageQueue = [];
-                        // operation to take when message(s) arrive.
-                        // this operation will be swapped out once initial "sync" is complete
-                        // to immediately ingest messsages.
-                        var receiveMessages = function () {
-                            var messages = [];
-                            for (var _i = 0; _i < arguments.length; _i++) {
-                                messages[_i] = arguments[_i];
-                            }
-                            return messageQueue.push.apply(messageQueue, __spreadArray([], __read(messages), false));
-                        };
-                        // start subscriptions
-                        var onCreateSub = models[name_1].onCreate(arg).subscribe({
-                            next: function (item) {
-                                receiveMessages({ item: item, type: 'create' });
-                            },
-                            error: function (error) {
-                                subscriber.error({ type: 'onCreate', error: error });
-                            },
-                        });
-                        var onUpdateSub = models[name_1].onUpdate(arg).subscribe({
-                            next: function (item) {
-                                receiveMessages({ item: item, type: 'update' });
-                            },
-                            error: function (error) {
-                                subscriber.error({ type: 'onUpdate', error: error });
-                            },
-                        });
-                        var onDeleteSub = models[name_1].onDelete(arg).subscribe({
-                            next: function (item) {
-                                receiveMessages({ item: item, type: 'delete' });
-                            },
-                            error: function (error) {
-                                subscriber.error({ type: 'onDelete', error: error });
-                            },
-                        });
-                        // consumes a list of messages and sends a snapshot
-                        function ingestMessages(messages) {
-                            var e_2, _a;
-                            try {
-                                for (var messages_1 = __values(messages), messages_1_1 = messages_1.next(); !messages_1_1.done; messages_1_1 = messages_1.next()) {
-                                    var message = messages_1_1.value;
-                                    var idx = findIndexByFields(message.item, items, pkFields);
-                                    switch (message.type) {
-                                        case 'create':
-                                            if (idx < 0)
-                                                items.push(message.item);
-                                            break;
-                                        case 'update':
-                                            if (idx >= 0)
-                                                items[idx] = message.item;
-                                            break;
-                                        case 'delete':
-                                            if (idx >= 0)
-                                                items.splice(idx, 1);
-                                            break;
-                                        default:
-                                            console.error('Unrecognized message in observeQuery.', message);
-                                    }
-                                }
-                            }
-                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                            finally {
-                                try {
-                                    if (messages_1_1 && !messages_1_1.done && (_a = messages_1.return)) _a.call(messages_1);
-                                }
-                                finally { if (e_2) throw e_2.error; }
-                            }
-                            subscriber.next({
-                                items: items,
-                                isSynced: true,
-                            });
-                        }
-                        var pkFields = resolvePKFields(model);
-                        // initial results
-                        (function () { return __awaiter(_this, void 0, void 0, function () {
-                            var firstPage, nextToken, _a, page, errors, _nextToken, isSynced, errors_1, errors_1_1, error;
-                            var e_3, _b;
-                            return __generator(this, function (_c) {
-                                switch (_c.label) {
-                                    case 0:
-                                        firstPage = true;
-                                        nextToken = null;
-                                        _c.label = 1;
-                                    case 1:
-                                        if (!(!subscriber.closed && (firstPage || nextToken))) return [3 /*break*/, 3];
-                                        firstPage = false;
-                                        return [4 /*yield*/, models[name_1].list(__assign(__assign({}, arg), { nextToken: nextToken }))];
-                                    case 2:
-                                        _a = _c.sent(), page = _a.data, errors = _a.errors, _nextToken = _a.nextToken;
-                                        nextToken = _nextToken;
-                                        items.push.apply(items, __spreadArray([], __read(page), false));
-                                        isSynced = messageQueue.length === 0 &&
-                                            (nextToken === null || nextToken === undefined);
-                                        subscriber.next({
-                                            items: items,
-                                            isSynced: isSynced,
-                                        });
-                                        if (Array.isArray(errors)) {
-                                            try {
-                                                for (errors_1 = (e_3 = void 0, __values(errors)), errors_1_1 = errors_1.next(); !errors_1_1.done; errors_1_1 = errors_1.next()) {
-                                                    error = errors_1_1.value;
-                                                    subscriber.error(error);
-                                                }
-                                            }
-                                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                                            finally {
-                                                try {
-                                                    if (errors_1_1 && !errors_1_1.done && (_b = errors_1.return)) _b.call(errors_1);
-                                                }
-                                                finally { if (e_3) throw e_3.error; }
-                                            }
-                                        }
-                                        return [3 /*break*/, 1];
-                                    case 3:
-                                        // play through the queue
-                                        if (messageQueue.length > 0) {
-                                            ingestMessages(messageQueue);
-                                        }
-                                        // switch the queue to write directly to the items collection
-                                        receiveMessages = function () {
-                                            var messages = [];
-                                            for (var _i = 0; _i < arguments.length; _i++) {
-                                                messages[_i] = arguments[_i];
-                                            }
-                                            ingestMessages(messages);
-                                            return items.length;
-                                        };
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); })();
-                        // when subscriber unsubscribes, tear down internal subs
-                        return function () {
-                            // 1. tear down internal subs
-                            onCreateSub.unsubscribe();
-                            onUpdateSub.unsubscribe();
-                            onDeleteSub.unsubscribe();
-                            // 2. there is no need to explicitly stop paging. instead, we
-                            // just check `subscriber.closed` above before fetching each page.
-                        };
-                    });
-                };
+                models[name][operationPrefix] = observeQueryFactory(models, model);
             }
             else {
-                models[name_1][operationPrefix] = function (arg, options) { return __awaiter(_this, void 0, void 0, function () {
-                    var query, variables, auth, _a, data, extensions, _b, key_2, flattenedResult, _c, initialized, error_2;
-                    return __generator(this, function (_d) {
-                        switch (_d.label) {
-                            case 0:
-                                query = generateGraphQLDocument(modelIntrospection.models, name_1, operation, options);
-                                variables = buildGraphQLVariables(model, operation, arg, modelIntrospection);
-                                _d.label = 1;
-                            case 1:
-                                _d.trys.push([1, 3, , 4]);
-                                auth = authModeParams(client, options);
-                                return [4 /*yield*/, client.graphql(__assign(__assign({}, auth), { query: query, variables: variables }))];
-                            case 2:
-                                _a = (_d.sent()), data = _a.data, extensions = _a.extensions;
-                                // flatten response
-                                if (data !== undefined) {
-                                    _b = __read(Object.keys(data), 1), key_2 = _b[0];
-                                    flattenedResult = flattenItems(data)[key_2];
-                                    if (options === null || options === void 0 ? void 0 : options.selectionSet) {
-                                        return [2 /*return*/, { data: flattenedResult, extensions: extensions }];
-                                    }
-                                    else {
-                                        _c = __read(initializeModel(client, name_1, [flattenedResult], modelIntrospection, auth.authMode, auth.authToken), 1), initialized = _c[0];
-                                        return [2 /*return*/, { data: initialized, extensions: extensions }];
-                                    }
-                                }
-                                else {
-                                    return [2 /*return*/, { data: null, extensions: extensions }];
-                                }
-                                return [3 /*break*/, 4];
-                            case 3:
-                                error_2 = _d.sent();
-                                if (error_2.errors) {
-                                    // graphql errors pass through
-                                    return [2 /*return*/, error_2];
-                                }
-                                else {
-                                    // non-graphql errors re re-thrown
-                                    throw error_2;
-                                }
-                                return [3 /*break*/, 4];
-                            case 4: return [2 /*return*/];
-                        }
-                    });
-                }); };
+                models[name][operationPrefix] = getFactory(client, modelIntrospection, model, operation);
             }
         });
-    };
-    try {
-        // TODO: refactor this to use separate methods for each CRUDL.
-        // Doesn't make sense to gen the methods dynamically given the different args and return values
-        for (var _d = __values(Object.values(modelIntrospection.models)), _e = _d.next(); !_e.done; _e = _d.next()) {
-            var model = _e.value;
-            _loop_1(model);
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
-        }
-        finally { if (e_1) throw e_1.error; }
     }
     return models;
 }

package/lib-esm/internals/operations/get.d.ts

@@ -0,0 +1,2 @@
+import { AmplifyServer } from '@aws-amplify/core/internals/adapter-core';
+export declare function getFactory(client: any, modelIntrospection: any, model: any, operation: any, context?: boolean): (contextSpec: AmplifyServer.ContextSpec, arg?: any, options?: any) => Promise<any>;

package/lib-esm/internals/operations/get.js

@@ -0,0 +1,55 @@
+import { initializeModel, generateGraphQLDocument, buildGraphQLVariables, flattenItems, authModeParams, } from '../APIClient';
+export function getFactory(client, modelIntrospection, model, operation, context = false) {
+    const getWithContext = async (contextSpec, arg, options) => {
+        return _get(client, modelIntrospection, model, arg, options, operation, contextSpec);
+    };
+    const get = async (arg, options) => {
+        return _get(client, modelIntrospection, model, arg, options, operation, context);
+    };
+    return context ? getWithContext : get;
+}
+async function _get(client, modelIntrospection, model, arg, options, operation, context) {
+    const { name } = model;
+    const query = generateGraphQLDocument(modelIntrospection.models, name, operation, options);
+    const variables = buildGraphQLVariables(model, operation, arg, modelIntrospection);
+    try {
+        const auth = authModeParams(client, options);
+        const { data, extensions } = context
+            ? (await client.graphql(context, {
+                ...auth,
+                query,
+                variables,
+            }))
+            : (await client.graphql({
+                ...auth,
+                query,
+                variables,
+            }));
+        // flatten response
+        if (data !== undefined) {
+            const [key] = Object.keys(data);
+            const flattenedResult = flattenItems(data)[key];
+            if (options?.selectionSet) {
+                return { data: flattenedResult, extensions };
+            }
+            else {
+                // TODO: refactor to avoid destructuring here
+                const [initialized] = initializeModel(client, name, [flattenedResult], modelIntrospection, auth.authMode, auth.authToken, context);
+                return { data: initialized, extensions };
+            }
+        }
+        else {
+            return { data: null, extensions };
+        }
+    }
+    catch (error) {
+        if (error.errors) {
+            // graphql errors pass through
+            return error;
+        }
+        else {
+            // non-graphql errors re re-thrown
+            throw error;
+        }
+    }
+}

package/lib-esm/internals/operations/list.d.ts

@@ -0,0 +1,2 @@
+import { AmplifyServer } from '@aws-amplify/core/internals/adapter-core';
+export declare function listFactory(client: any, modelIntrospection: any, model: any, context?: boolean): (contextSpec: AmplifyServer.ContextSpec, args?: any) => Promise<any>;

package/lib-esm/internals/operations/list.js

@@ -0,0 +1,67 @@
+import { initializeModel, generateGraphQLDocument, buildGraphQLVariables, flattenItems, authModeParams, } from '../APIClient';
+export function listFactory(client, modelIntrospection, model, context = false) {
+    const listWithContext = async (contextSpec, args) => {
+        return _list(client, modelIntrospection, model, args, contextSpec);
+    };
+    const list = async (args) => {
+        return _list(client, modelIntrospection, model, args, context);
+    };
+    return context ? listWithContext : list;
+}
+async function _list(client, modelIntrospection, model, args, context) {
+    const { name } = model;
+    const query = generateGraphQLDocument(modelIntrospection.models, name, 'LIST', args);
+    const variables = buildGraphQLVariables(model, 'LIST', args, modelIntrospection);
+    try {
+        const auth = authModeParams(client, args);
+        const { data, extensions } = context
+            ? (await client.graphql(context, {
+                ...auth,
+                query,
+                variables,
+            }))
+            : (await client.graphql({
+                ...auth,
+                query,
+                variables,
+            }));
+        // flatten response
+        if (data !== undefined) {
+            const [key] = Object.keys(data);
+            if (data[key].items) {
+                const flattenedResult = flattenItems(data)[key];
+                // don't init if custom selection set
+                if (args?.selectionSet) {
+                    return {
+                        data: flattenedResult,
+                        nextToken: data[key].nextToken,
+                        extensions,
+                    };
+                }
+                else {
+                    const initialized = initializeModel(client, name, flattenedResult, modelIntrospection, auth.authMode, auth.authToken, context);
+                    return {
+                        data: initialized,
+                        nextToken: data[key].nextToken,
+                        extensions,
+                    };
+                }
+            }
+            return {
+                data: data[key],
+                nextToken: data[key].nextToken,
+                extensions,
+            };
+        }
+    }
+    catch (error) {
+        if (error.errors) {
+            // graphql errors pass through
+            return error;
+        }
+        else {
+            // non-graphql errors re re-thrown
+            throw error;
+        }
+    }
+}

package/lib-esm/internals/operations/observeQuery.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from 'rxjs';
+export declare function observeQueryFactory(models: any, model: any): (arg?: any) => Observable<unknown>;

package/lib-esm/internals/operations/observeQuery.js

@@ -0,0 +1,115 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Observable } from 'rxjs';
+import { findIndexByFields, resolvePKFields } from '../../utils';
+export function observeQueryFactory(models, model) {
+    const { name } = model;
+    const observeQuery = (arg) => new Observable(subscriber => {
+        // what we'll be sending to our subscribers
+        const items = [];
+        // To enqueue subscription messages while we collect our initial
+        // result set.
+        const messageQueue = [];
+        // operation to take when message(s) arrive.
+        // this operation will be swapped out once initial "sync" is complete
+        // to immediately ingest messsages.
+        let receiveMessages = (...messages) => {
+            return messageQueue.push(...messages);
+        };
+        // start subscriptions
+        const onCreateSub = models[name].onCreate(arg).subscribe({
+            next(item) {
+                receiveMessages({ item, type: 'create' });
+            },
+            error(error) {
+                subscriber.error({ type: 'onCreate', error });
+            },
+        });
+        const onUpdateSub = models[name].onUpdate(arg).subscribe({
+            next(item) {
+                receiveMessages({ item, type: 'update' });
+            },
+            error(error) {
+                subscriber.error({ type: 'onUpdate', error });
+            },
+        });
+        const onDeleteSub = models[name].onDelete(arg).subscribe({
+            next(item) {
+                receiveMessages({ item, type: 'delete' });
+            },
+            error(error) {
+                subscriber.error({ type: 'onDelete', error });
+            },
+        });
+        // consumes a list of messages and sends a snapshot
+        function ingestMessages(messages) {
+            for (const message of messages) {
+                const idx = findIndexByFields(message.item, items, pkFields);
+                switch (message.type) {
+                    case 'create':
+                        if (idx < 0)
+                            items.push(message.item);
+                        break;
+                    case 'update':
+                        if (idx >= 0)
+                            items[idx] = message.item;
+                        break;
+                    case 'delete':
+                        if (idx >= 0)
+                            items.splice(idx, 1);
+                        break;
+                    default:
+                        console.error('Unrecognized message in observeQuery.', message);
+                }
+            }
+            subscriber.next({
+                items,
+                isSynced: true,
+            });
+        }
+        const pkFields = resolvePKFields(model);
+        // initial results
+        (async () => {
+            let firstPage = true;
+            let nextToken = null;
+            while (!subscriber.closed && (firstPage || nextToken)) {
+                firstPage = false;
+                const { data: page, errors, nextToken: _nextToken, } = await models[name].list({ ...arg, nextToken });
+                nextToken = _nextToken;
+                items.push(...page);
+                // if there are no more pages and no items we already know about
+                // that need to be merged in from sub, we're "synced"
+                const isSynced = messageQueue.length === 0 &&
+                    (nextToken === null || nextToken === undefined);
+                subscriber.next({
+                    items,
+                    isSynced,
+                });
+                if (Array.isArray(errors)) {
+                    for (const error of errors) {
+                        subscriber.error(error);
+                    }
+                }
+            }
+            // play through the queue
+            if (messageQueue.length > 0) {
+                ingestMessages(messageQueue);
+            }
+            // switch the queue to write directly to the items collection
+            receiveMessages = (...messages) => {
+                ingestMessages(messages);
+                return items.length;
+            };
+        })();
+        // when subscriber unsubscribes, tear down internal subs
+        return () => {
+            // 1. tear down internal subs
+            onCreateSub.unsubscribe();
+            onUpdateSub.unsubscribe();
+            onDeleteSub.unsubscribe();
+            // 2. there is no need to explicitly stop paging. instead, we
+            // just check `subscriber.closed` above before fetching each page.
+        };
+    });
+    return observeQuery;
+}

package/lib-esm/internals/operations/subscription.d.ts

@@ -0,0 +1 @@
+export declare function subscriptionFactory(client: any, modelIntrospection: any, model: any, operation: any): (args?: any) => import("rxjs").Observable<any>;

package/lib-esm/internals/operations/subscription.js

@@ -0,0 +1,23 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { map } from 'rxjs';
+import { initializeModel, generateGraphQLDocument, buildGraphQLVariables, authModeParams, } from '../APIClient';
+export function subscriptionFactory(client, modelIntrospection, model, operation) {
+    const { name } = model;
+    const subscription = (args) => {
+        const query = generateGraphQLDocument(modelIntrospection.models, name, operation);
+        const variables = buildGraphQLVariables(model, operation, args, modelIntrospection);
+        const auth = authModeParams(client, args);
+        const observable = client.graphql({
+            ...auth,
+            query,
+            variables,
+        });
+        return observable.pipe(map(value => {
+            const [key] = Object.keys(value.data);
+            const [initialized] = initializeModel(client, name, [value.data[key]], modelIntrospection, auth.authMode, auth.authToken);
+            return initialized;
+        }));
+    };
+    return subscription;
+}

package/lib-esm/internals/server/generateClient.d.ts

@@ -0,0 +1,11 @@
+import { V6ClientSSRRequest, V6ClientSSRCookies, ServerClientGenerationParams, CommonPublicClientOptions } from '../../types';
+/**
+ * @private
+ *
+ * Creates a client that can be used to make GraphQL requests, using a provided `AmplifyClassV6`
+ * compatible context object for config and auth fetching.
+ *
+ * @param params
+ * @returns
+ */
+export declare function generateClient<T extends Record<any, any> = never, ClientType extends V6ClientSSRRequest<T> | V6ClientSSRCookies<T> = V6ClientSSRCookies<T>>(params: ServerClientGenerationParams & CommonPublicClientOptions): ClientType;