@ngrx/signals 17.0.0-beta.0

package/schematics-core/utility/visitors.js

@@ -0,0 +1,250 @@
+"use strict";
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitDecorator = exports.visitNgModules = exports.visitComponents = exports.visitNgModuleExports = exports.visitNgModuleImports = exports.visitTemplates = exports.visitTSSourceFiles = void 0;
+var ts = require("typescript");
+var core_1 = require("@angular-devkit/core");
+function visitTSSourceFiles(tree, visitor) {
+    var e_1, _a;
+    var result = undefined;
+    try {
+        for (var _b = __values(visit(tree.root)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var sourceFile = _c.value;
+            result = visitor(sourceFile, tree, result);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return result;
+}
+exports.visitTSSourceFiles = visitTSSourceFiles;
+function visitTemplates(tree, visitor) {
+    visitTSSourceFiles(tree, function (source) {
+        visitComponents(source, function (_, decoratorExpressionNode) {
+            ts.forEachChild(decoratorExpressionNode, function findTemplates(n) {
+                if (ts.isPropertyAssignment(n) && ts.isIdentifier(n.name)) {
+                    if (n.name.text === 'template' &&
+                        ts.isStringLiteralLike(n.initializer)) {
+                        // Need to add an offset of one to the start because the template quotes are
+                        // not part of the template content.
+                        var templateStartIdx = n.initializer.getStart() + 1;
+                        visitor({
+                            fileName: source.fileName,
+                            content: n.initializer.text,
+                            inline: true,
+                            start: templateStartIdx,
+                        }, tree);
+                        return;
+                    }
+                    else if (n.name.text === 'templateUrl' &&
+                        ts.isStringLiteralLike(n.initializer)) {
+                        var parts = (0, core_1.normalize)(source.fileName).split('/').slice(0, -1);
+                        var templatePath = (0, core_1.resolve)((0, core_1.normalize)(parts.join('/')), (0, core_1.normalize)(n.initializer.text));
+                        if (!tree.exists(templatePath)) {
+                            return;
+                        }
+                        var fileContent = tree.read(templatePath);
+                        if (!fileContent) {
+                            return;
+                        }
+                        visitor({
+                            fileName: templatePath,
+                            content: fileContent.toString(),
+                            inline: false,
+                            start: 0,
+                        }, tree);
+                        return;
+                    }
+                }
+                ts.forEachChild(n, findTemplates);
+            });
+        });
+    });
+}
+exports.visitTemplates = visitTemplates;
+function visitNgModuleImports(sourceFile, callback) {
+    visitNgModuleProperty(sourceFile, callback, 'imports');
+}
+exports.visitNgModuleImports = visitNgModuleImports;
+function visitNgModuleExports(sourceFile, callback) {
+    visitNgModuleProperty(sourceFile, callback, 'exports');
+}
+exports.visitNgModuleExports = visitNgModuleExports;
+function visitNgModuleProperty(sourceFile, callback, property) {
+    visitNgModules(sourceFile, function (_, decoratorExpressionNode) {
+        ts.forEachChild(decoratorExpressionNode, function findTemplates(n) {
+            if (ts.isPropertyAssignment(n) &&
+                ts.isIdentifier(n.name) &&
+                n.name.text === property &&
+                ts.isArrayLiteralExpression(n.initializer)) {
+                callback(n, n.initializer.elements);
+                return;
+            }
+            ts.forEachChild(n, findTemplates);
+        });
+    });
+}
+function visitComponents(sourceFile, callback) {
+    visitDecorator(sourceFile, 'Component', callback);
+}
+exports.visitComponents = visitComponents;
+function visitNgModules(sourceFile, callback) {
+    visitDecorator(sourceFile, 'NgModule', callback);
+}
+exports.visitNgModules = visitNgModules;
+function visitDecorator(sourceFile, decoratorName, callback) {
+    ts.forEachChild(sourceFile, function findClassDeclaration(node) {
+        if (!ts.isClassDeclaration(node)) {
+            ts.forEachChild(node, findClassDeclaration);
+        }
+        var classDeclarationNode = node;
+        var decorators = ts.getDecorators(classDeclarationNode);
+        if (!decorators || !decorators.length) {
+            return;
+        }
+        var componentDecorator = decorators.find(function (d) {
+            return (ts.isCallExpression(d.expression) &&
+                ts.isIdentifier(d.expression.expression) &&
+                d.expression.expression.text === decoratorName);
+        });
+        if (!componentDecorator) {
+            return;
+        }
+        var expression = componentDecorator.expression;
+        if (!ts.isCallExpression(expression)) {
+            return;
+        }
+        var _a = __read(expression.arguments, 1), arg = _a[0];
+        if (!arg || !ts.isObjectLiteralExpression(arg)) {
+            return;
+        }
+        callback(classDeclarationNode, arg);
+    });
+}
+exports.visitDecorator = visitDecorator;
+function visit(directory) {
+    var _a, _b, path, entry, content, source, e_2_1, _c, _d, path, e_3_1;
+    var e_2, _e, e_3, _f;
+    return __generator(this, function (_g) {
+        switch (_g.label) {
+            case 0:
+                _g.trys.push([0, 5, 6, 7]);
+                _a = __values(directory.subfiles), _b = _a.next();
+                _g.label = 1;
+            case 1:
+                if (!!_b.done) return [3 /*break*/, 4];
+                path = _b.value;
+                if (!(path.endsWith('.ts') && !path.endsWith('.d.ts'))) return [3 /*break*/, 3];
+                entry = directory.file(path);
+                if (!entry) return [3 /*break*/, 3];
+                content = entry.content;
+                source = ts.createSourceFile(entry.path, content.toString().replace(/^\uFEFF/, ''), ts.ScriptTarget.Latest, true);
+                return [4 /*yield*/, source];
+            case 2:
+                _g.sent();
+                _g.label = 3;
+            case 3:
+                _b = _a.next();
+                return [3 /*break*/, 1];
+            case 4: return [3 /*break*/, 7];
+            case 5:
+                e_2_1 = _g.sent();
+                e_2 = { error: e_2_1 };
+                return [3 /*break*/, 7];
+            case 6:
+                try {
+                    if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                }
+                finally { if (e_2) throw e_2.error; }
+                return [7 /*endfinally*/];
+            case 7:
+                _g.trys.push([7, 12, 13, 14]);
+                _c = __values(directory.subdirs), _d = _c.next();
+                _g.label = 8;
+            case 8:
+                if (!!_d.done) return [3 /*break*/, 11];
+                path = _d.value;
+                if (path === 'node_modules') {
+                    return [3 /*break*/, 10];
+                }
+                return [5 /*yield**/, __values(visit(directory.dir(path)))];
+            case 9:
+                _g.sent();
+                _g.label = 10;
+            case 10:
+                _d = _c.next();
+                return [3 /*break*/, 8];
+            case 11: return [3 /*break*/, 14];
+            case 12:
+                e_3_1 = _g.sent();
+                e_3 = { error: e_3_1 };
+                return [3 /*break*/, 14];
+            case 13:
+                try {
+                    if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                }
+                finally { if (e_3) throw e_3.error; }
+                return [7 /*endfinally*/];
+            case 14: return [2 /*return*/];
+        }
+    });
+}
+//# sourceMappingURL=visitors.js.map

package/schematics-core/utility/visitors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitors.js","sourceRoot":"","sources":["../../../../../modules/signals/schematics-core/utility/visitors.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ts from 'typescript';\nimport { normalize, resolve } from '@angular-devkit/core';\nimport { Tree, DirEntry } from '@angular-devkit/schematics';\n\nexport function visitTSSourceFiles<Result = void>(\n  tree: Tree,\n  visitor: (\n    sourceFile: ts.SourceFile,\n    tree: Tree,\n    result?: Result\n  ) => Result | undefined\n): Result | undefined {\n  let result: Result | undefined = undefined;\n  for (const sourceFile of visit(tree.root)) {\n    result = visitor(sourceFile, tree, result);\n  }\n\n  return result;\n}\n\nexport function visitTemplates(\n  tree: Tree,\n  visitor: (\n    template: {\n      fileName: string;\n      content: string;\n      inline: boolean;\n      start: number;\n    },\n    tree: Tree\n  ) => void\n): void {\n  visitTSSourceFiles(tree, (source) => {\n    visitComponents(source, (_, decoratorExpressionNode) => {\n      ts.forEachChild(decoratorExpressionNode, function findTemplates(n) {\n        if (ts.isPropertyAssignment(n) && ts.isIdentifier(n.name)) {\n          if (\n            n.name.text === 'template' &&\n            ts.isStringLiteralLike(n.initializer)\n          ) {\n            // Need to add an offset of one to the start because the template quotes are\n            // not part of the template content.\n            const templateStartIdx = n.initializer.getStart() + 1;\n            visitor(\n              {\n                fileName: source.fileName,\n                content: n.initializer.text,\n                inline: true,\n                start: templateStartIdx,\n              },\n              tree\n            );\n            return;\n          } else if (\n            n.name.text === 'templateUrl' &&\n            ts.isStringLiteralLike(n.initializer)\n          ) {\n            const parts = normalize(source.fileName).split('/').slice(0, -1);\n            const templatePath = resolve(\n              normalize(parts.join('/')),\n              normalize(n.initializer.text)\n            );\n            if (!tree.exists(templatePath)) {\n              return;\n            }\n\n            const fileContent = tree.read(templatePath);\n            if (!fileContent) {\n              return;\n            }\n\n            visitor(\n              {\n                fileName: templatePath,\n                content: fileContent.toString(),\n                inline: false,\n                start: 0,\n              },\n              tree\n            );\n            return;\n          }\n        }\n\n        ts.forEachChild(n, findTemplates);\n      });\n    });\n  });\n}\n\nexport function visitNgModuleImports(\n  sourceFile: ts.SourceFile,\n  callback: (\n    importNode: ts.PropertyAssignment,\n    elementExpressions: ts.NodeArray<ts.Expression>\n  ) => void\n) {\n  visitNgModuleProperty(sourceFile, callback, 'imports');\n}\n\nexport function visitNgModuleExports(\n  sourceFile: ts.SourceFile,\n  callback: (\n    exportNode: ts.PropertyAssignment,\n    elementExpressions: ts.NodeArray<ts.Expression>\n  ) => void\n) {\n  visitNgModuleProperty(sourceFile, callback, 'exports');\n}\n\nfunction visitNgModuleProperty(\n  sourceFile: ts.SourceFile,\n  callback: (\n    nodes: ts.PropertyAssignment,\n    elementExpressions: ts.NodeArray<ts.Expression>\n  ) => void,\n  property: string\n) {\n  visitNgModules(sourceFile, (_, decoratorExpressionNode) => {\n    ts.forEachChild(decoratorExpressionNode, function findTemplates(n) {\n      if (\n        ts.isPropertyAssignment(n) &&\n        ts.isIdentifier(n.name) &&\n        n.name.text === property &&\n        ts.isArrayLiteralExpression(n.initializer)\n      ) {\n        callback(n, n.initializer.elements);\n        return;\n      }\n\n      ts.forEachChild(n, findTemplates);\n    });\n  });\n}\nexport function visitComponents(\n  sourceFile: ts.SourceFile,\n  callback: (\n    classDeclarationNode: ts.ClassDeclaration,\n    decoratorExpressionNode: ts.ObjectLiteralExpression\n  ) => void\n) {\n  visitDecorator(sourceFile, 'Component', callback);\n}\n\nexport function visitNgModules(\n  sourceFile: ts.SourceFile,\n  callback: (\n    classDeclarationNode: ts.ClassDeclaration,\n    decoratorExpressionNode: ts.ObjectLiteralExpression\n  ) => void\n) {\n  visitDecorator(sourceFile, 'NgModule', callback);\n}\n\nexport function visitDecorator(\n  sourceFile: ts.SourceFile,\n  decoratorName: string,\n  callback: (\n    classDeclarationNode: ts.ClassDeclaration,\n    decoratorExpressionNode: ts.ObjectLiteralExpression\n  ) => void\n) {\n  ts.forEachChild(sourceFile, function findClassDeclaration(node) {\n    if (!ts.isClassDeclaration(node)) {\n      ts.forEachChild(node, findClassDeclaration);\n    }\n\n    const classDeclarationNode = node as ts.ClassDeclaration;\n    const decorators = ts.getDecorators(classDeclarationNode);\n\n    if (!decorators || !decorators.length) {\n      return;\n    }\n\n    const componentDecorator = decorators.find((d) => {\n      return (\n        ts.isCallExpression(d.expression) &&\n        ts.isIdentifier(d.expression.expression) &&\n        d.expression.expression.text === decoratorName\n      );\n    });\n\n    if (!componentDecorator) {\n      return;\n    }\n\n    const { expression } = componentDecorator;\n    if (!ts.isCallExpression(expression)) {\n      return;\n    }\n\n    const [arg] = expression.arguments;\n    if (!arg || !ts.isObjectLiteralExpression(arg)) {\n      return;\n    }\n\n    callback(classDeclarationNode, arg);\n  });\n}\n\nfunction* visit(directory: DirEntry): IterableIterator<ts.SourceFile> {\n  for (const path of directory.subfiles) {\n    if (path.endsWith('.ts') && !path.endsWith('.d.ts')) {\n      const entry = directory.file(path);\n      if (entry) {\n        const content = entry.content;\n        const source = ts.createSourceFile(\n          entry.path,\n          content.toString().replace(/^\\uFEFF/, ''),\n          ts.ScriptTarget.Latest,\n          true\n        );\n        yield source;\n      }\n    }\n  }\n\n  for (const path of directory.subdirs) {\n    if (path === 'node_modules') {\n      continue;\n    }\n\n    yield* visit(directory.dir(path));\n  }\n}\n"]}

package/src/deep-signal.d.ts

@@ -0,0 +1,6 @@
+import { Signal } from '@angular/core';
+import { IsUnknownRecord } from './ts-helpers';
+export type DeepSignal<T> = Signal<T> & (T extends Record<string, unknown> ? IsUnknownRecord<T> extends true ? unknown : Readonly<{
+    [K in keyof T]: T[K] extends Record<string, unknown> ? IsUnknownRecord<T[K]> extends true ? Signal<T[K]> : DeepSignal<T[K]> : Signal<T[K]>;
+}> : unknown);
+export declare function toDeepSignal<T>(signal: Signal<T>): DeepSignal<T>;

package/src/helpers.d.ts

@@ -0,0 +1 @@
+export declare function excludeKeys<Obj extends Record<string, unknown>, Keys extends string[]>(obj: Obj, keys: Keys): Omit<Obj, Keys[number]>;

package/src/index.d.ts

@@ -0,0 +1,8 @@
+export { PartialStateUpdater, patchState } from './patch-state';
+export { signalState } from './signal-state';
+export { signalStore } from './signal-store';
+export { signalStoreFeature, type } from './signal-store-feature';
+export { withComputed } from './with-computed';
+export { withHooks } from './with-hooks';
+export { withMethods } from './with-methods';
+export { withState } from './with-state';

package/src/patch-state.d.ts

@@ -0,0 +1,3 @@
+import { SignalStateMeta } from './signal-state';
+export type PartialStateUpdater<State extends Record<string, unknown>> = (state: State) => Partial<State>;
+export declare function patchState<State extends Record<string, unknown>>(signalState: SignalStateMeta<State>, ...updaters: Array<Partial<State> | PartialStateUpdater<State>>): void;

package/src/signal-state.d.ts

@@ -0,0 +1,11 @@
+import { WritableSignal } from '@angular/core';
+import { DeepSignal } from './deep-signal';
+import { HasFunctionKeys } from './ts-helpers';
+export declare const STATE_SIGNAL: unique symbol;
+export type SignalStateMeta<State extends Record<string, unknown>> = {
+    [STATE_SIGNAL]: WritableSignal<State>;
+};
+type SignalStateCheck<State> = HasFunctionKeys<State> extends false | undefined ? unknown : '@ngrx/signals: signal state cannot contain `Function` property or method names';
+type SignalState<State extends Record<string, unknown>> = DeepSignal<State> & SignalStateMeta<State>;
+export declare function signalState<State extends Record<string, unknown>>(initialState: State & SignalStateCheck<State>): SignalState<State>;
+export {};

package/src/signal-store-feature.d.ts

@@ -0,0 +1,22 @@
+import { EmptyFeatureResult, MergeFeatureResults, SignalStoreFeature, SignalStoreFeatureResult } from './signal-store-models';
+import { Prettify } from './ts-helpers';
+export declare function signalStoreFeature<F1 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>): SignalStoreFeature<EmptyFeatureResult, F1>;
+export declare function signalStoreFeature<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>): SignalStoreFeature<EmptyFeatureResult, MergeFeatureResults<[F1, F2]>>;
+export declare function signalStoreFeature<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>): SignalStoreFeature<EmptyFeatureResult, MergeFeatureResults<[F1, F2, F3]>>;
+export declare function signalStoreFeature<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>): SignalStoreFeature<EmptyFeatureResult, MergeFeatureResults<[F1, F2, F3, F4]>>;
+export declare function signalStoreFeature<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4]>, F5>): SignalStoreFeature<EmptyFeatureResult, MergeFeatureResults<[F1, F2, F3, F4, F5]>>;
+export declare function signalStoreFeature<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult, F6 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4]>, F5>, f6: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5]>, F6>): SignalStoreFeature<EmptyFeatureResult, MergeFeatureResults<[F1, F2, F3, F4, F5, F6]>>;
+export declare function signalStoreFeature<Input extends Partial<SignalStoreFeatureResult>, F1 extends SignalStoreFeatureResult>(input: Input, f1: SignalStoreFeature<Prettify<EmptyFeatureResult & Input>, F1>): SignalStoreFeature<Prettify<EmptyFeatureResult & Input>, F1>;
+export declare function signalStoreFeature<Input extends Partial<SignalStoreFeatureResult>, F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult>(input: Input, f1: SignalStoreFeature<Prettify<EmptyFeatureResult & Input>, F1>, f2: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1]>, F2>): SignalStoreFeature<Prettify<EmptyFeatureResult & Input>, MergeFeatureResults<[F1, F2]>>;
+export declare function signalStoreFeature<Input extends Partial<SignalStoreFeatureResult>, F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult>(input: Input, f1: SignalStoreFeature<Prettify<EmptyFeatureResult & Input>, F1>, f2: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1]>, F2>, f3: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1, F2]>, F3>): SignalStoreFeature<Prettify<EmptyFeatureResult & Input>, MergeFeatureResults<[F1, F2, F3]>>;
+export declare function signalStoreFeature<Input extends Partial<SignalStoreFeatureResult>, F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult>(Input: Input, f1: SignalStoreFeature<Prettify<EmptyFeatureResult & Input>, F1>, f2: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1]>, F2>, f3: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1, F2, F3]>, F4>): SignalStoreFeature<Prettify<EmptyFeatureResult & Input>, MergeFeatureResults<[F1, F2, F3, F4]>>;
+export declare function signalStoreFeature<Input extends Partial<SignalStoreFeatureResult>, F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult>(input: Input, f1: SignalStoreFeature<Prettify<EmptyFeatureResult & Input>, F1>, f2: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1]>, F2>, f3: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1, F2, F3, F4]>, F5>): SignalStoreFeature<Prettify<EmptyFeatureResult & Input>, MergeFeatureResults<[F1, F2, F3, F4, F5]>>;
+export declare function signalStoreFeature<Input extends Partial<SignalStoreFeatureResult>, F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult, F6 extends SignalStoreFeatureResult>(input: Input, f1: SignalStoreFeature<Prettify<EmptyFeatureResult & Input>, F1>, f2: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1]>, F2>, f3: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[Prettify<EmptyFeatureResult & Input>, F1, F2, F3, F4]>, F5>, f6: SignalStoreFeature<MergeFeatureResults<[
+    Prettify<EmptyFeatureResult & Input>,
+    F1,
+    F2,
+    F3,
+    F4,
+    F5
+]>, F6>): SignalStoreFeature<Prettify<EmptyFeatureResult & Input>, MergeFeatureResults<[F1, F2, F3, F4, F5, F6]>>;
+export declare function type<T>(): T;

package/src/signal-store-models.d.ts

@@ -0,0 +1,49 @@
+import { Signal } from '@angular/core';
+import { DeepSignal } from './deep-signal';
+import { SignalStateMeta } from './signal-state';
+import { IsUnknownRecord, Prettify } from './ts-helpers';
+export type SignalStoreConfig = {
+    providedIn: 'root';
+};
+export type SignalStoreSlices<State> = {
+    [Key in keyof State]: State[Key] extends Record<string, unknown> ? IsUnknownRecord<State[Key]> extends true ? Signal<State[Key]> : DeepSignal<State[Key]> : Signal<State[Key]>;
+};
+export type SignalStore<FeatureResult extends SignalStoreFeatureResult> = Prettify<SignalStoreSlices<FeatureResult['state']> & FeatureResult['signals'] & FeatureResult['methods'] & SignalStateMeta<Prettify<FeatureResult['state']>>>;
+export type SignalsDictionary = Record<string, Signal<unknown>>;
+export type MethodsDictionary = Record<string, (...args: any[]) => unknown>;
+export type SignalStoreHooks = {
+    onInit?: () => void;
+    onDestroy?: () => void;
+};
+export type InnerSignalStore<State extends Record<string, unknown> = Record<string, unknown>, Signals extends SignalsDictionary = SignalsDictionary, Methods extends MethodsDictionary = MethodsDictionary> = {
+    slices: SignalStoreSlices<State>;
+    signals: Signals;
+    methods: Methods;
+    hooks: SignalStoreHooks;
+} & SignalStateMeta<State>;
+export type SignalStoreFeatureResult = {
+    state: Record<string, unknown>;
+    signals: SignalsDictionary;
+    methods: MethodsDictionary;
+};
+export type EmptyFeatureResult = {
+    state: {};
+    signals: {};
+    methods: {};
+};
+export type SignalStoreFeature<Input extends SignalStoreFeatureResult = SignalStoreFeatureResult, Output extends SignalStoreFeatureResult = SignalStoreFeatureResult> = (store: InnerSignalStore<Input['state'], Input['signals'], Input['methods']>) => InnerSignalStore<Output['state'], Output['signals'], Output['methods']>;
+export type MergeFeatureResults<FeatureResults extends SignalStoreFeatureResult[]> = FeatureResults extends [] ? {} : FeatureResults extends [infer First extends SignalStoreFeatureResult] ? First : FeatureResults extends [
+    infer First extends SignalStoreFeatureResult,
+    infer Second extends SignalStoreFeatureResult
+] ? MergeTwoFeatureResults<First, Second> : FeatureResults extends [
+    infer First extends SignalStoreFeatureResult,
+    infer Second extends SignalStoreFeatureResult,
+    ...infer Rest extends SignalStoreFeatureResult[]
+] ? MergeFeatureResults<[MergeTwoFeatureResults<First, Second>, ...Rest]> : never;
+type FeatureResultKeys<FeatureResult extends SignalStoreFeatureResult> = keyof FeatureResult['state'] | keyof FeatureResult['signals'] | keyof FeatureResult['methods'];
+type MergeTwoFeatureResults<First extends SignalStoreFeatureResult, Second extends SignalStoreFeatureResult> = {
+    state: Omit<First['state'], FeatureResultKeys<Second>>;
+    signals: Omit<First['signals'], FeatureResultKeys<Second>>;
+    methods: Omit<First['methods'], FeatureResultKeys<Second>>;
+} & Second;
+export {};

package/src/signal-store.d.ts

@@ -0,0 +1,21 @@
+import { Type } from '@angular/core';
+import { EmptyFeatureResult, InnerSignalStore, MergeFeatureResults, SignalStore, SignalStoreConfig, SignalStoreFeature, SignalStoreFeatureResult } from './signal-store-models';
+export declare function signalStore<F1 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>): Type<SignalStore<F1>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>): Type<SignalStore<MergeFeatureResults<[F1, F2]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3, F4]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4]>, F5>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3, F4, F5]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult, F6 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4]>, F5>, f6: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5]>, F6>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3, F4, F5, F6]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult, F6 extends SignalStoreFeatureResult, F7 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4]>, F5>, f6: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5]>, F6>, f7: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5, F6]>, F7>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3, F4, F5, F6, F7]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult, F6 extends SignalStoreFeatureResult, F7 extends SignalStoreFeatureResult, F8 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4]>, F5>, f6: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5]>, F6>, f7: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5, F6]>, F7>, f8: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5, F6, F7]>, F8>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3, F4, F5, F6, F7, F8]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult, F6 extends SignalStoreFeatureResult, F7 extends SignalStoreFeatureResult, F8 extends SignalStoreFeatureResult, F9 extends SignalStoreFeatureResult>(f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4]>, F5>, f6: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5]>, F6>, f7: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5, F6]>, F7>, f8: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5, F6, F7]>, F8>, f9: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5, F6, F7, F8]>, F9>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3, F4, F5, F6, F7, F8, F9]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult>(config: SignalStoreConfig, f1: SignalStoreFeature<EmptyFeatureResult, F1>): Type<SignalStore<F1>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult>(config: SignalStoreConfig, f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>): Type<SignalStore<MergeFeatureResults<[F1, F2]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult>(config: SignalStoreConfig, f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult>(config: SignalStoreConfig, f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3, F4]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult>(config: SignalStoreConfig, f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4]>, F5>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3, F4, F5]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult, F6 extends SignalStoreFeatureResult>(config: SignalStoreConfig, f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4]>, F5>, f6: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5]>, F6>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3, F4, F5, F6]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult, F6 extends SignalStoreFeatureResult, F7 extends SignalStoreFeatureResult>(config: SignalStoreConfig, f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4]>, F5>, f6: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5]>, F6>, f7: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5, F6]>, F7>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3, F4, F5, F6, F7]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult, F6 extends SignalStoreFeatureResult, F7 extends SignalStoreFeatureResult, F8 extends SignalStoreFeatureResult>(config: SignalStoreConfig, f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4]>, F5>, f6: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5]>, F6>, f7: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5, F6]>, F7>, f8: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5, F6, F7]>, F8>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3, F4, F5, F6, F7, F8]>>>;
+export declare function signalStore<F1 extends SignalStoreFeatureResult, F2 extends SignalStoreFeatureResult, F3 extends SignalStoreFeatureResult, F4 extends SignalStoreFeatureResult, F5 extends SignalStoreFeatureResult, F6 extends SignalStoreFeatureResult, F7 extends SignalStoreFeatureResult, F8 extends SignalStoreFeatureResult, F9 extends SignalStoreFeatureResult>(config: SignalStoreConfig, f1: SignalStoreFeature<EmptyFeatureResult, F1>, f2: SignalStoreFeature<{} & F1, F2>, f3: SignalStoreFeature<MergeFeatureResults<[F1, F2]>, F3>, f4: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3]>, F4>, f5: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4]>, F5>, f6: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5]>, F6>, f7: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5, F6]>, F7>, f8: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5, F6, F7]>, F8>, f9: SignalStoreFeature<MergeFeatureResults<[F1, F2, F3, F4, F5, F6, F7, F8]>, F9>): Type<SignalStore<MergeFeatureResults<[F1, F2, F3, F4, F5, F6, F7, F8, F9]>>>;
+export declare function getInitialInnerStore(): InnerSignalStore;

package/src/ts-helpers.d.ts

@@ -0,0 +1,11 @@
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type IsUnknownRecord<T> = string extends keyof T ? true : number extends keyof T ? true : false;
+export type HasOptionalProps<T> = T extends Required<T> ? false : true;
+export type HasFunctionKeys<T> = T extends Record<string, unknown> ? {
+    [K in keyof T]: K extends keyof Function ? true : HasFunctionKeys<T[K]>;
+}[keyof T] : false;
+export type HasNestedFunctionKeys<T> = {
+    [K in keyof T]: HasFunctionKeys<T[K]>;
+}[keyof T];

package/src/with-computed.d.ts

@@ -0,0 +1,5 @@
+import { EmptyFeatureResult, SignalsDictionary, SignalStoreFeature, SignalStoreFeatureResult, SignalStoreSlices } from './signal-store-models';
+import { Prettify } from './ts-helpers';
+export declare function withComputed<Input extends SignalStoreFeatureResult, Signals extends SignalsDictionary>(signalsFactory: (store: Prettify<SignalStoreSlices<Input['state']> & Input['signals']>) => Signals): SignalStoreFeature<Input, EmptyFeatureResult & {
+    signals: Signals;
+}>;

package/src/with-hooks.d.ts

@@ -0,0 +1,9 @@
+import { SignalStateMeta } from './signal-state';
+import { EmptyFeatureResult, SignalStoreFeature, SignalStoreSlices, SignalStoreFeatureResult } from './signal-store-models';
+import { Prettify } from './ts-helpers';
+type HooksFactory<Input extends SignalStoreFeatureResult> = (store: Prettify<SignalStoreSlices<Input['state']> & Input['signals'] & Input['methods'] & SignalStateMeta<Prettify<Input['state']>>>) => void;
+export declare function withHooks<Input extends SignalStoreFeatureResult>(hooks: {
+    onInit?: HooksFactory<Input>;
+    onDestroy?: HooksFactory<Input>;
+}): SignalStoreFeature<Input, EmptyFeatureResult>;
+export {};

package/src/with-methods.d.ts

@@ -0,0 +1,6 @@
+import { SignalStateMeta } from './signal-state';
+import { EmptyFeatureResult, MethodsDictionary, SignalStoreFeature, SignalStoreFeatureResult, SignalStoreSlices } from './signal-store-models';
+import { Prettify } from './ts-helpers';
+export declare function withMethods<Input extends SignalStoreFeatureResult, Methods extends MethodsDictionary>(methodsFactory: (store: Prettify<SignalStoreSlices<Input['state']> & Input['signals'] & Input['methods'] & SignalStateMeta<Prettify<Input['state']>>>) => Methods): SignalStoreFeature<Input, EmptyFeatureResult & {
+    methods: Methods;
+}>;

package/src/with-state.d.ts

@@ -0,0 +1,10 @@
+import { EmptyFeatureResult, SignalStoreFeature } from './signal-store-models';
+import { HasNestedFunctionKeys, HasOptionalProps, IsUnknownRecord } from './ts-helpers';
+type WithStateCheck<State> = IsUnknownRecord<State> extends true ? '@ngrx/signals: root state keys must be string literals' : HasOptionalProps<State> extends true ? '@ngrx/signals: root state slices cannot be optional' : HasNestedFunctionKeys<State> extends false | undefined ? unknown : '@ngrx/signals: nested state slices cannot contain `Function` property or method names';
+export declare function withState<State extends Record<string, unknown>>(state: State & WithStateCheck<State>): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
+    state: State;
+}>;
+export declare function withState<State extends Record<string, unknown>>(stateFactory: () => State & WithStateCheck<State>): SignalStoreFeature<EmptyFeatureResult, EmptyFeatureResult & {
+    state: State;
+}>;
+export {};