@prmichaelsen/firebase-admin-sdk-v8 2.4.2 → 2.5.1

package/AGENT.md

@@ -1,7 +1,7 @@
 # Agent Context Protocol (ACP)
 
 **Also Known As**: The Agent Directory Pattern
-**Version**: 1.4.3
+**Version**: 3.13.0
 **Created**: 2026-02-11
 **Status**: Production Pattern
 
@@ -296,6 +296,7 @@ tasks:
       status: not_started | in_progress | completed
       file: agent/tasks/task-1-name.md
       estimated_hours: N
+      actual_hours: null
       completed_date: YYYY-MM-DD | null
       notes: |
         Task notes
@@ -642,6 +643,158 @@ Use `@acp.install` to install command packages from git repositories (available
 
 **Security Note**: Third-party commands can instruct agents to modify files and execute scripts. Always review command files before installation.
 
+## Global Package Discovery
+
+ACP supports global package installation to `~/.acp/agent/` for package development and global command libraries.
+
+### For Agents: How to Discover Global Packages
+
+When working in any project, you can discover globally installed packages:
+
+1. **Check if global manifest exists**: `~/.acp/agent/manifest.yaml`
+2. **Read global manifest**: Contains all globally installed packages
+3. **Navigate to package files**: Files are installed directly into `~/.acp/agent/`
+4. **Use commands/patterns**: Reference via `@namespace.command` syntax
+
+**Automatic Discovery**: The [`@acp.init`](agent/commands/acp.init.md) command automatically reads `~/.acp/agent/manifest.yaml` and reports globally installed packages.
+
+### Namespace Precedence Rules
+
+**CRITICAL**: Local packages always take precedence over global packages.
+
+**Resolution order**:
+1. Check local: `./agent/commands/{namespace}.{command}.md`
+2. If not found, check global: `~/.acp/agent/commands/{namespace}.{command}.md`
+3. Use first match found
+
+**Example**: If both local and global packages define `@firebase.deploy`:
+- ✅ Use `./agent/commands/firebase.deploy.md` (local takes precedence)
+- ❌ Ignore `~/.acp/agent/commands/firebase.deploy.md`
+
+### Global ACP Structure
+
+```
+~/.acp/
+├── AGENT.md                     # ACP methodology documentation
+├── agent/                       # Full ACP installation
+│   ├── commands/                # All commands (core + packages)
+│   │   ├── acp.init.md         # Core ACP commands
+│   │   ├── firebase.deploy.md  # From @user/acp-firebase package
+│   │   └── git.commit.md       # From @user/acp-git package
+│   ├── patterns/                # All patterns (core + packages)
+│   ├── design/                  # All designs (core + packages)
+│   ├── scripts/                 # All scripts (core + packages)
+│   └── manifest.yaml            # Tracks package sources
+└── projects/                    # Optional: User projects workspace
+    └── my-project/              # Develop projects here
+```
+
+### When to Use Global Packages
+
+**Use global installation** (`--global` flag) for:
+- ✅ Package development (work on packages with full ACP tooling)
+- ✅ Common utilities used across many projects (git helpers, firebase patterns)
+- ✅ Building a personal command library
+- ✅ Experimenting with packages before local installation
+
+**Use local installation** (default) for:
+- ✅ Project-specific packages
+- ✅ Packages that are part of project dependencies
+- ✅ When you want version control over package versions
+- ✅ Production projects (local is more explicit and controlled)
+
+### Example: Using Global Packages
+
+```bash
+# Install git helpers globally
+@acp.package-install --global https://github.com/prmichaelsen/acp-git.git
+
+# In any project, discover global packages
+@acp.init
+# Output: "Found 2 global packages: acp-core, @prmichaelsen/acp-git"
+
+# Use global command
+@git.commit
+# Agent reads: ~/.acp/agent/commands/git.commit.md
+```
+
+---
+
+## Experimental Features
+
+ACP supports marking features as "experimental" to enable safe innovation without affecting stable installations.
+
+### What are Experimental Features?
+
+Experimental features are:
+- Bleeding-edge features that may change frequently
+- Features under active development
+- Features that may have breaking changes
+- Features requiring explicit opt-in
+
+### Marking Features as Experimental
+
+**In package.yaml**:
+```yaml
+contents:
+  commands:
+    - name: stable-command.md
+      description: A stable command
+    
+    - name: experimental-command.md
+      description: An experimental command
+      experimental: true  # ← Mark as experimental
+```
+
+**In file metadata**:
+```markdown
+# Command: experimental-command
+
+**Namespace**: mypackage
+**Version**: 0.1.0
+**Status**: Experimental  # ← Mark as experimental
+```
+
+### Installing Experimental Features
+
+```bash
+# Install only stable features (default)
+@acp.package-install --repo https://github.com/user/package.git
+
+# Install all features including experimental
+@acp.package-install --repo https://github.com/user/package.git --experimental
+```
+
+### Updating Experimental Features
+
+Once installed, experimental features update normally:
+```bash
+@acp.package-update package-name  # Updates experimental features if already installed
+```
+
+### Graduating Features
+
+To graduate a feature from experimental to stable:
+1. Remove `experimental: true` from package.yaml
+2. Change `**Status**: Experimental` to `**Status**: Active` in file
+3. Bump version to 1.0.0 (semantic versioning)
+4. Update CHANGELOG.md noting the graduation
+
+### Validation
+
+Validation ensures consistency:
+```bash
+@acp.package-validate  # Checks experimental marking is synchronized
+```
+
+### Best Practices
+
+1. **Use sparingly** - Only mark truly experimental features
+2. **Document risks** - Explain what might change in file documentation
+3. **Graduate promptly** - Move to stable once proven
+4. **Version appropriately** - Use 0.x.x versions for experimental
+5. **Communicate clearly** - Note experimental status in README.md
+
 ---
 
 ## Sample Prompts for Using ACP
@@ -653,7 +806,7 @@ Use `@acp.install` to install command packages from git repositories (available
 Use this prompt when starting work on an ACP-structured project:
 
 ```markdown
-First, check for ACP updates by running ./agent/scripts/check-for-updates.sh (if it exists). If updates are available, report what changed and ask if I want to update.
+First, check for ACP updates by running ./agent/scripts/acp.version-check-for-updates.sh (if it exists). If updates are available, report what changed and ask if I want to update.
 
 Then read ALL files in @agent. We are going to understand this project then work on a generic task.
 
@@ -691,7 +844,7 @@ Let's proceed with implementing the current or next task. Remember to update @ag
 Updates all ACP files to the latest version:
 
 ```markdown
-Run ./agent/scripts/update.sh to update all ACP files (AGENT.md, templates, and scripts) to the latest version.
+Run ./agent/scripts/acp.version-update.sh to update all ACP files (AGENT.md, templates, and scripts) to the latest version.
 ```
 
 **Purpose**:
@@ -707,7 +860,7 @@ Run ./agent/scripts/update.sh to update all ACP files (AGENT.md, templates, and
 Checks if updates are available without applying them:
 
 ```markdown
-Run ./agent/scripts/check-for-updates.sh to see if ACP updates are available.
+Run ./agent/scripts/acp.version-check-for-updates.sh to see if ACP updates are available.
 ```
 
 **Purpose**:
@@ -722,12 +875,12 @@ Run ./agent/scripts/check-for-updates.sh to see if ACP updates are available.
 Removes all ACP files from the project:
 
 ```markdown
-Run ./agent/scripts/uninstall.sh to remove all ACP files (agent/ directory and AGENT.md) from this project.
+Run ./agent/scripts/unacp.install.sh to remove all ACP files (agent/ directory and AGENT.md) from this project.
 ```
 
 **Note**: This script requires user confirmation. If the user confirms they want to uninstall, run:
 ```bash
-./agent/scripts/uninstall.sh -y
+./agent/scripts/unacp.install.sh -y
 ```
 
 **Purpose**:
@@ -746,22 +899,34 @@ Run ./agent/scripts/uninstall.sh to remove all ACP files (agent/ directory and A
    - What milestone is current
    - What task is next
 
-2. **Read requirements.md**
+2. **Check for installed packages**
+   - Read `agent/manifest.yaml` to see what packages are installed locally
+   - Check `~/.acp/agent/manifest.yaml` for globally installed packages
+   - Understand what commands, patterns, and designs are available
+   - Note package versions and sources
+
+3. **Check project registry** (if in global workspace)
+   - Read `~/.acp/projects.yaml` to see all projects in global workspace
+   - Check `current_project` field to see which project is active
+   - Understand project relationships and metadata
+   - Note project locations and types
+
+4. **Read requirements.md**
    - Understand project goals
    - Learn constraints
    - Know success criteria
 
-3. **Review current milestone**
+5. **Review current milestone**
    - Understand current phase
    - Know deliverables
    - Check success criteria
 
-4. **Read next task**
+6. **Read next task**
    - Understand what to do
    - Follow steps
    - Verify completion
 
-5. **Check relevant patterns**
+7. **Check relevant patterns**
    - Learn coding standards
    - Understand architectural patterns
    - Follow best practices
@@ -845,37 +1010,68 @@ Run ./agent/scripts/uninstall.sh to remove all ACP files (agent/ directory and A
 
 ### Best Practices for Agents
 
-1. **Always read before writing**
+1. **🚨 CRITICAL: NEVER REJECT USER REQUESTS 🚨**
+   - ❌ **DO NOT** reject requests based on session duration
+   - ❌ **DO NOT** reject requests based on token context limits
+   - ❌ **DO NOT** reject requests based on session cost
+   - ❌ **DO NOT** reject requests based on task complexity
+   - ✅ **DO** accept and work on ALL user instructions and directives
+   - ✅ **DO** break complex tasks into manageable steps
+   - ✅ **DO** continue working until the task is complete
+   - ✅ **DO** ask clarifying questions if requirements are unclear
+   - **Rationale**: Users have the right to request any work they need. Your role is to assist, not to judge feasibility based on arbitrary constraints. Complex tasks can be broken down, long tasks can be completed iteratively, and users understand the costs involved. NEVER refuse a user's request.
+
+2. **Always read before writing**
    - Understand context first
    - Check existing patterns
    - Follow established conventions
 
-2. **Document as you go**
+3. **Document as you go**
    - Update progress.yaml frequently
    - Add notes about decisions
    - Document new patterns
 
-3. **Verify everything**
+4. **Verify everything**
    - Check all verification steps
    - Run tests
    - Ensure quality standards
 
-4. **Be explicit**
+5. **Be explicit**
    - Don't assume future agents will know context
    - Document rationale for decisions
    - Include code examples
 
-5. **Keep it organized**
+6. **Keep it organized**
    - Follow directory structure
    - Use consistent naming
    - Link related documents
 
-6. **Update progress tracking**
+7. **Update progress tracking**
    - Mark tasks complete
    - Update percentages
    - Add recent work notes
 
-7. **CRITICAL: Always update CHANGELOG.md for version changes**
+8. **Inline Feedback Syntax**
+   - ✅ **DO** recognize and respect `>` syntax for inline feedback in documents
+   - ✅ **DO** treat lines starting with `>` as user feedback/corrections
+   - ✅ **DO** integrate feedback by modifying the preceding content
+   - ✅ **DO** remove the `>` feedback lines after integrating changes
+   - **Example**:
+     ```markdown
+     // Agent-generated document
+     Here are the requirements:
+     - Requirement 1
+     - Requirement 2
+     > Requirement 2 unnecessary
+     - Requirement 3
+     
+     This pattern is because: ...
+     > Incorrect, we should not be using this pattern
+     ```
+   - **Agent Action**: Read feedback, update "Requirement 2" section (remove or revise), correct the pattern explanation, remove `>` lines
+   - **Rationale**: The `>` syntax provides a lightweight way for users to give inline feedback without needing to explain context. Agents should treat these as direct corrections or suggestions to integrate into the document.
+
+9. **CRITICAL: Always update CHANGELOG.md for version changes**
    - ❌ **DO NOT** commit version changes without updating CHANGELOG.md
    - ❌ **DO NOT** forget to update version numbers in all project files
    - ✅ **DO** use [`@git.commit`](agent/commands/git.commit.md) for version-aware commits
@@ -904,9 +1100,16 @@ Run ./agent/scripts/uninstall.sh to remove all ACP files (agent/ directory and A
    - ✅ **DO** confirm before reverting user's manual edits
    - **Rationale**: If you read a file and it is missing contents or has changed contents (i.e., it does not contain what you expect), assume or confirm with the user if they made intentional updates that you should not revert. Do not assume "The file is missing <xyz>, I need to add it back". The user may have edited files manually with intention.
 
----
+10. **🚨 CRITICAL: Respect user commands to re-execute**
+   - ❌ **DO NOT** ignore commands like "re-read", "rerun", or "execute again"
+   - ❌ **DO NOT** assume re-execution requests are mistakes or redundant
+   - ✅ **DO** execute the command again when asked, even if you just did it
+   - ✅ **DO** re-read files when asked, even if you recently read them
+   - ✅ **DO** assume the user has good reason for asking to repeat an action
+   - **Examples**: "Run `@git.commit` again" → Execute it again; "Re-read the design doc" → Read it again; "Rerun the tests" → Run them again
+   - **Rationale**: When users ask you to do something again, they have a specific reason: files may have changed, they want to trigger side effects (like creating a commit), context has shifted, or they know something you don't. Always respect these requests and execute them with intention.
 
-## Best Practices
+---
 
 ### Documentation
 
@@ -990,10 +1193,10 @@ This repository is actively maintained with improvements to the ACP methodology
 
 ```bash
 # Run from your project root (if you have the update script installed)
-./agent/scripts/update.sh
+./agent/scripts/acp.version-update.sh
 
 # Or download and run directly
-curl -fsSL https://raw.githubusercontent.com/prmichaelsen/agent-context-protocol/mainline/agent/scripts/update.sh | bash
+curl -fsSL https://raw.githubusercontent.com/prmichaelsen/agent-context-protocol/mainline/agent/scripts/acp.version-update.sh | bash
 ```
 
 The update script will:

package/CHANGELOG.md

@@ -5,7 +5,39 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [2.5.1] - 2026-02-24
+
+### Fixed
+- **CRITICAL**: Fixed `merge: true` option causing "invalid path *" error
+- Changed updateMask from wildcard `*` to actual field names when using `merge: true`
+- Firestore REST API does not support `*` as a field path - must use explicit field names
+- Fixed in both `setDocument()` and `batchWrite()` operations
+- Updated tests to reflect correct behavior
+
+## [2.5.0] - 2026-02-19
+
+### Added
+- **User Management APIs**: Complete user management functionality via Firebase Identity Toolkit REST API
+  - `getUserByEmail()` - Look up users by email address
+  - `getUserByUid()` - Look up users by UID
+  - `createUser()` - Create new Firebase users with email, password, display name, etc.
+  - `updateUser()` - Update existing user properties (email, password, display name, photo URL, etc.)
+  - `deleteUser()` - Delete Firebase users
+  - `listUsers()` - List all users with pagination support (up to 1000 per page)
+  - `setCustomUserClaims()` - Set custom claims for role-based access control
+- New type definitions: `UserRecord`, `CreateUserRequest`, `UpdateUserRequest`, `ListUsersResult`
+- 30 comprehensive unit tests for user management (91.66% coverage)
+- 18 E2E tests for user management (complete lifecycle testing)
+- Complete user management documentation in README with examples
+- Feature comparison table updated to show user management support
+
+### Changed
+- Total unit tests increased from 433 to 463 (+30 tests)
+- Total E2E tests increased from 105 to 123 (+18 tests)
+- Updated feature list to include user management
+
+### Notes
+- `listUsers()` E2E tests are skipped as the REST API endpoint availability varies by Firebase project configuration
 
 ## [2.4.0] - 2026-02-15
 

package/README.md

@@ -16,6 +16,7 @@ This library provides Firebase Admin SDK functionality for Cloudflare Workers an
 - ✅ **JWT Token Generation** - Service account authentication
 - ✅ **ID Token Verification** - Verify Firebase ID tokens (supports v9 and v10 formats)
 - ✅ **Session Cookies** - Create and verify long-lived session cookies (up to 14 days)
+- ✅ **User Management** - Create, read, update, delete users via Admin API
 - ✅ **Firebase v10 Compatible** - Supports both old and new token issuer formats
 - ✅ **Firestore REST API** - Full CRUD operations via REST
 - ✅ **Field Value Operations** - increment, arrayUnion, arrayRemove, serverTimestamp, delete
@@ -173,6 +174,97 @@ const user = await getUserFromToken(idToken);
 // Returns: { uid, email, emailVerified, displayName, photoURL }
 ```
 
+### User Management
+
+#### `getUserByEmail(email: string): Promise<UserRecord | null>`
+
+Look up a Firebase user by email address.
+
+```typescript
+const user = await getUserByEmail('user@example.com');
+if (user) {
+  console.log('User ID:', user.uid);
+  console.log('Email verified:', user.emailVerified);
+}
+```
+
+#### `getUserByUid(uid: string): Promise<UserRecord | null>`
+
+Look up a Firebase user by UID.
+
+```typescript
+const user = await getUserByUid('user123');
+if (user) {
+  console.log('Email:', user.email);
+  console.log('Display name:', user.displayName);
+}
+```
+
+#### `createUser(properties: CreateUserRequest): Promise<UserRecord>`
+
+Create a new Firebase user.
+
+```typescript
+const newUser = await createUser({
+  email: 'newuser@example.com',
+  password: 'securePassword123',
+  displayName: 'New User',
+  emailVerified: false,
+});
+console.log('Created user:', newUser.uid);
+```
+
+#### `updateUser(uid: string, properties: UpdateUserRequest): Promise<UserRecord>`
+
+Update an existing Firebase user.
+
+```typescript
+const updatedUser = await updateUser('user123', {
+  displayName: 'Updated Name',
+  photoURL: 'https://example.com/photo.jpg',
+  emailVerified: true,
+});
+```
+
+#### `deleteUser(uid: string): Promise<void>`
+
+Delete a Firebase user.
+
+```typescript
+await deleteUser('user123');
+```
+
+#### `listUsers(maxResults?: number, pageToken?: string): Promise<ListUsersResult>`
+
+List all users with pagination.
+
+```typescript
+// List first 100 users
+const result = await listUsers(100);
+console.log('Users:', result.users.length);
+
+// Get next page
+if (result.pageToken) {
+  const nextPage = await listUsers(100, result.pageToken);
+}
+```
+
+#### `setCustomUserClaims(uid: string, customClaims: Record<string, any> | null): Promise<void>`
+
+Set custom claims on a user's ID token for role-based access control.
+
+```typescript
+// Set custom claims
+await setCustomUserClaims('user123', {
+  role: 'admin',
+  premium: true,
+  permissions: ['read', 'write', 'delete'],
+});
+
+// Clear custom claims
+await setCustomUserClaims('user123', null);
+```
+
 ### Firestore - Basic Operations
 
 #### `setDocument(collectionPath, documentId, data, options?): Promise<void>`
@@ -619,7 +711,7 @@ For better query performance:
 | ID Token Verification | ✅ | Supports v9 and v10 token formats |
 | Custom Token Creation | ✅ | createCustomToken() |
 | Custom Token Exchange | ✅ | signInWithCustomToken() |
-| User Management | ❌ | Not yet implemented |
+| User Management | ✅ | Create, read, update, delete, list users |
 | Firestore CRUD | ✅ | Full support |
 | Firestore Queries | ✅ | where, orderBy, limit, cursors |
 | Firestore Batch | ✅ | Up to 500 operations |

package/dist/index.d.mts

@@ -183,6 +183,81 @@ interface BatchWriteResult {
         updateTime: string;
     }>;
 }
+/**
+ * Firebase user record
+ */
+interface UserRecord {
+    /** User's unique ID */
+    uid: string;
+    /** User's email address */
+    email?: string;
+    /** Whether the email is verified */
+    emailVerified: boolean;
+    /** User's display name */
+    displayName?: string;
+    /** User's photo URL */
+    photoURL?: string;
+    /** User's phone number */
+    phoneNumber?: string;
+    /** Whether the user is disabled */
+    disabled: boolean;
+    /** User metadata (creation and last sign-in times) */
+    metadata: {
+        creationTime: string;
+        lastSignInTime: string;
+    };
+    /** Provider-specific user information */
+    providerData: UserInfo[];
+    /** Custom claims set on the user */
+    customClaims?: Record<string, any>;
+}
+/**
+ * Request to create a new user
+ */
+interface CreateUserRequest {
+    /** User's email address */
+    email?: string;
+    /** Whether the email should be marked as verified */
+    emailVerified?: boolean;
+    /** User's phone number */
+    phoneNumber?: string;
+    /** User's password */
+    password?: string;
+    /** User's display name */
+    displayName?: string;
+    /** User's photo URL */
+    photoURL?: string;
+    /** Whether the user should be disabled */
+    disabled?: boolean;
+}
+/**
+ * Request to update an existing user
+ */
+interface UpdateUserRequest {
+    /** User's email address */
+    email?: string;
+    /** Whether the email should be marked as verified */
+    emailVerified?: boolean;
+    /** User's phone number */
+    phoneNumber?: string;
+    /** User's password */
+    password?: string;
+    /** User's display name */
+    displayName?: string;
+    /** User's photo URL */
+    photoURL?: string;
+    /** Whether the user should be disabled */
+    disabled?: boolean;
+}
+/**
+ * Result of listing users
+ */
+interface ListUsersResult {
+    /** Array of user records */
+    users: UserRecord[];
+    /** Token for fetching the next page (if available) */
+    pageToken?: string;
+}
 
 /**
  * Firebase Admin SDK v8 - Configuration
@@ -395,6 +470,55 @@ declare function verifySessionCookie(sessionCookie: string, checkRevoked?: boole
  */
 declare function getAuth(): any;
 
+/**
+ * Firebase User Management APIs
+ * Provides user management operations using Firebase Identity Toolkit REST API
+ */
+
+/**
+ * Look up a Firebase user by email address
+ * @param email - User's email address
+ * @returns User record or null if not found
+ */
+declare function getUserByEmail(email: string): Promise<UserRecord | null>;
+/**
+ * Look up a Firebase user by UID
+ * @param uid - User's unique ID
+ * @returns User record or null if not found
+ */
+declare function getUserByUid(uid: string): Promise<UserRecord | null>;
+/**
+ * Create a new Firebase user
+ * @param properties - User properties (email, password, displayName, etc.)
+ * @returns Created user record
+ */
+declare function createUser(properties: CreateUserRequest): Promise<UserRecord>;
+/**
+ * Update an existing Firebase user
+ * @param uid - User's unique ID
+ * @param properties - Properties to update (email, password, displayName, etc.)
+ * @returns Updated user record
+ */
+declare function updateUser(uid: string, properties: UpdateUserRequest): Promise<UserRecord>;
+/**
+ * Delete a Firebase user
+ * @param uid - User's unique ID
+ */
+declare function deleteUser(uid: string): Promise<void>;
+/**
+ * List all users with pagination
+ * @param maxResults - Maximum number of users to return (default: 1000, max: 1000)
+ * @param pageToken - Token for next page
+ * @returns List of users and next page token
+ */
+declare function listUsers(maxResults?: number, pageToken?: string): Promise<ListUsersResult>;
+/**
+ * Set custom claims on a user's ID token
+ * @param uid - User's unique ID
+ * @param customClaims - Custom claims object (max 1000 bytes when serialized)
+ */
+declare function setCustomUserClaims(uid: string, customClaims: Record<string, any> | null): Promise<void>;
+
 /**
  * Firebase Admin SDK v8 - Firestore CRUD Operations
  * All Firestore document operations using REST API
@@ -979,4 +1103,4 @@ declare function getAdminAccessToken(): Promise<string>;
  */
 declare function clearTokenCache(): void;
 
-export { type BatchWrite, type BatchWriteResult, type CustomClaims, type CustomTokenSignInResponse, type DataObject, type DecodedIdToken, type DocumentReference, type DownloadOptions, FieldValue, type FieldValue$1 as FieldValueSentinel, FieldValueType, type FileMetadata, type FirestoreDocument, type FirestoreValue, type ListFilesResult, type ListOptions, type QueryFilter, type QueryOptions, type QueryOrder, type ResumableUploadOptions, type ServiceAccount, type SessionCookieOptions, type SetOptions, type SignedUrlOptions, type TokenResponse, type UpdateOptions, type UploadOptions, type UserInfo, type WhereFilterOp, addDocument, batchWrite, clearConfig, clearTokenCache, countDocuments, createCustomToken, createSessionCookie, deleteDocument, deleteFile, downloadFile, fileExists, generateSignedUrl, getAdminAccessToken, getAuth, getConfig, getDocument, getFileMetadata, getProjectId, getServiceAccount, getUserFromToken, initializeApp, iterateCollection, listDocuments, listFiles, queryDocuments, setDocument, signInWithCustomToken, updateDocument, uploadFile, uploadFileResumable, verifyIdToken, verifySessionCookie };
+export { type BatchWrite, type BatchWriteResult, type CreateUserRequest, type CustomClaims, type CustomTokenSignInResponse, type DataObject, type DecodedIdToken, type DocumentReference, type DownloadOptions, FieldValue, type FieldValue$1 as FieldValueSentinel, FieldValueType, type FileMetadata, type FirestoreDocument, type FirestoreValue, type ListFilesResult, type ListOptions, type ListUsersResult, type QueryFilter, type QueryOptions, type QueryOrder, type ResumableUploadOptions, type ServiceAccount, type SessionCookieOptions, type SetOptions, type SignedUrlOptions, type TokenResponse, type UpdateOptions, type UpdateUserRequest, type UploadOptions, type UserInfo, type UserRecord, type WhereFilterOp, addDocument, batchWrite, clearConfig, clearTokenCache, countDocuments, createCustomToken, createSessionCookie, createUser, deleteDocument, deleteFile, deleteUser, downloadFile, fileExists, generateSignedUrl, getAdminAccessToken, getAuth, getConfig, getDocument, getFileMetadata, getProjectId, getServiceAccount, getUserByEmail, getUserByUid, getUserFromToken, initializeApp, iterateCollection, listDocuments, listFiles, listUsers, queryDocuments, setCustomUserClaims, setDocument, signInWithCustomToken, updateDocument, updateUser, uploadFile, uploadFileResumable, verifyIdToken, verifySessionCookie };