@agility/management-sdk 0.1.32 → 0.1.33

package/.cursor/api-documentation-manifest.md

@@ -0,0 +1,275 @@
+# API Methods Documentation Manifest - Modular Structure
+
+## Overview
+Comprehensive documentation restructure for all API method classes in `/src/apiMethods/` folder. This manifest organizes the work into a modular documentation system with separate files for each method class, improving navigation and maintainability.
+
+## New Documentation Structure
+
+### Main README.md
+- **Concise Overview** - Introduction, getting started, authentication
+- **Method Class Index** - Links to individual documentation files
+- **Quick Reference** - Brief description of each method class
+- **Global Examples** - Cross-method workflow examples
+
+### Individual Method Documentation (`./docs/`)
+Each method class gets its own documentation file following this structure:
+
+```
+./docs/
+├── asset-methods.md      # AssetMethods - File and media management
+├── batch-methods.md      # BatchMethods - Batch workflow operations  
+├── container-methods.md  # ContainerMethods - Container management
+├── content-methods.md    # ContentMethods - Content item operations
+├── instance-methods.md   # InstanceMethods - Instance-level operations
+├── instance-user-methods.md # InstanceUserMethods - Instance user management
+├── model-methods.md      # ModelMethods - Content model operations
+├── page-methods.md       # PageMethods - Page management operations
+├── server-user-methods.md # ServerUserMethods - Server user operations
+└── webhook-methods.md    # WebhookMethods - Webhook management
+```
+
+### Individual File Structure Template
+```markdown
+# Agility CMS & Management API TypeScript SDK
+
+## [Method Class Name] Methods
+
+[Description of the method class and its purpose]
+
+**Important Notes:**
+- Key information about the class
+- Usage patterns and best practices
+
+### Function List
+- [functionName1](#functionname1) - Brief description
+- [functionName2](#functionname2) - Brief description
+
+### [Function Documentation]
+[All function details with examples]
+
+---
+
+## Navigation
+- [← Back to Main Documentation](../README.md)
+- [AssetMethods](./asset-methods.md)
+- [BatchMethods](./batch-methods.md)
+- [ContainerMethods](./container-methods.md)
+- [ContentMethods](./content-methods.md)
+- [InstanceMethods](./instance-methods.md)
+- [InstanceUserMethods](./instance-user-methods.md)
+- [ModelMethods](./model-methods.md)
+- [PageMethods](./page-methods.md)
+- [ServerUserMethods](./server-user-methods.md)
+- [WebhookMethods](./webhook-methods.md)
+```
+
+## Method Classes Overview
+1. **AssetMethods** (15 functions) - File and media management operations
+2. **BatchMethods** (7 functions) - Batch workflow operations 
+3. **ContainerMethods** (8 functions) - Container management operations
+4. **ContentMethods** (13 functions) - Content item operations
+5. **InstanceMethods** (1 function) - Instance-level operations
+6. **InstanceUserMethods** (3 functions) - Instance user management
+7. **ModelMethods** (6 functions) - Content model operations
+8. **PageMethods** (17 functions) - Page management operations
+9. **ServerUserMethods** (2 functions) - Server user operations
+10. **WebhookMethods** (4 functions) - Webhook management operations
+
+## Benefits of Modular Structure
+- ✅ **Better Navigation** - Easy to find specific method documentation
+- ✅ **Improved Maintainability** - Individual files are easier to update
+- ✅ **Faster Loading** - Users only load documentation they need
+- ✅ **Better GitHub Experience** - Each file has reasonable size for web viewing
+- ✅ **Searchability** - Easier to search within specific method documentation
+- ✅ **Professional Structure** - Follows modern API documentation patterns
+
+## Implementation Phases
+
+### Phase 1: Modular Structure Setup
+- [x] ✅ Create `./docs/` directory structure
+- [x] ✅ Design individual file templates with navigation
+- [x] ✅ Restructure main README to be concise with method index
+- [ ] Set up cross-linking between documentation files
+
+### Phase 2: AssetMethods Documentation (`./docs/asset-methods.md`)
+- [x] ✅ Create asset-methods.md file with 15 functions
+- [x] ✅ Move existing AssetMethods documentation to new file
+- [x] ✅ Add function list table of contents
+- [x] ✅ Add navigation footer
+- Functions: deleteFile, moveFile, getMediaList, getGalleries, getGalleryById, getGalleryByName, getDefaultContainer, saveGallery, deleteGallery, getAssetByID, getAssetByUrl, upload, createFolder, deleteFolder, renameFolder
+
+### Phase 3: BatchMethods Documentation (`./docs/batch-methods.md`)
+- [ ] Create batch-methods.md file with 7 functions
+- [ ] Move existing BatchMethods documentation to new file
+- [ ] Add function list table of contents
+- [ ] Add navigation footer
+- Functions: getBatch, publishBatch, unpublishBatch, approveBatch, declineBatch, requestApprovalBatch, getBatchTypes
+
+### Phase 4: ContainerMethods Documentation (`./docs/container-methods.md`)
+- [ ] Create container-methods.md file with 8 functions
+- [ ] Move existing ContainerMethods documentation to new file
+- [ ] Add function list table of contents
+- [ ] Add navigation footer
+- Functions: getContainerByID, getContainersByModel, getContainerByReferenceName, getContainerSecurity, getContainerList, getNotificationList, saveContainer, deleteContainer
+
+### Phase 5: ContentMethods Documentation (`./docs/content-methods.md`)
+- [ ] Create content-methods.md file with 13 functions
+- [ ] Document all functions with returnBatchId flag support
+- [ ] Add function list table of contents
+- [ ] Add navigation footer
+- Functions: getContentItem, publishContent, unPublishContent, contentRequestApproval, approveContent, declineContent, deleteContent, saveContentItem, saveContentItems, getContentItems, getContentList, getContentHistory, getContentComments
+
+### Phase 6: InstanceMethods Documentation (`./docs/instance-methods.md`)
+- [ ] Create instance-methods.md file with 1 function
+- [ ] Document getLocales function
+- [ ] Add function list table of contents
+- [ ] Add navigation footer
+- Functions: getLocales
+
+### Phase 7: InstanceUserMethods Documentation (`./docs/instance-user-methods.md`)
+- [ ] Create instance-user-methods.md file with 3 functions
+- [ ] Document all user management functions
+- [ ] Add function list table of contents
+- [ ] Add navigation footer
+- Functions: getUsers, saveUser, deleteUser
+
+### Phase 8: ModelMethods Documentation (`./docs/model-methods.md`)
+- [ ] Create model-methods.md file with 6 functions
+- [ ] Document all content model functions
+- [ ] Add function list table of contents
+- [ ] Add navigation footer
+- Functions: getContentModel, getModelByReferenceName, getContentModules, getPageModules, saveModel, deleteModel
+
+### Phase 9: PageMethods Documentation (`./docs/page-methods.md`)
+- [ ] Create page-methods.md file with 17 functions
+- [ ] Document all functions with returnBatchId flag support
+- [ ] Add function list table of contents
+- [ ] Add navigation footer
+- Functions: getSitemap, getPageTemplates, getPageTemplate, getPageTemplateName, deletePageTemplate, getPageItemTemplates, savePageTemplate, getPage, publishPage, unPublishPage, pageRequestApproval, approvePage, declinePage, deletePage, savePage, getPageHistory, getPageComments
+
+### Phase 10: ServerUserMethods Documentation (`./docs/server-user-methods.md`)
+- [ ] Create server-user-methods.md file with 2 functions
+- [ ] Document server user functions
+- [ ] Add function list table of contents
+- [ ] Add navigation footer
+- Functions: me, you
+
+### Phase 11: WebhookMethods Documentation (`./docs/webhook-methods.md`)
+- [ ] Create webhook-methods.md file with 4 functions
+- [ ] Document all webhook functions
+- [ ] Add function list table of contents
+- [ ] Add navigation footer
+- Functions: webhookList, saveWebhook, getWebhook, deleteWebhook
+
+### Phase 12: Final Review & Polish
+- [ ] Review cross-linking between all documentation files
+- [ ] Ensure consistent formatting across all method files
+- [ ] Validate all navigation links work correctly
+- [ ] Test all code examples
+- [ ] Final proofreading across all documentation files
+- [ ] Update main README with final method index
+
+## Documentation Template Standards
+
+### Main README Template
+```markdown
+# Agility CMS & Management API TypeScript SDK
+
+## Table of Contents
+- [Getting Started](#getting-started)
+- [API Method Classes](#api-method-classes)
+- [Examples](#examples)
+
+## Getting Started
+[Authentication and setup information]
+
+## API Method Classes
+- [AssetMethods](./docs/asset-methods.md) - File and media management (15 functions)
+- [BatchMethods](./docs/batch-methods.md) - Batch workflow operations (7 functions)
+- [ContainerMethods](./docs/container-methods.md) - Container management (8 functions)
+- [ContentMethods](./docs/content-methods.md) - Content item operations (13 functions)
+- [InstanceMethods](./docs/instance-methods.md) - Instance-level operations (1 function)
+- [InstanceUserMethods](./docs/instance-user-methods.md) - Instance user management (3 functions)
+- [ModelMethods](./docs/model-methods.md) - Content model operations (6 functions)
+- [PageMethods](./docs/page-methods.md) - Page management operations (17 functions)
+- [ServerUserMethods](./docs/server-user-methods.md) - Server user operations (2 functions)
+- [WebhookMethods](./docs/webhook-methods.md) - Webhook management (4 functions)
+
+## Examples
+[Cross-method workflow examples]
+```
+
+### Individual Method File Template
+```markdown
+# Agility CMS & Management API TypeScript SDK
+
+## [MethodName] Methods
+
+Brief description of the method class purpose and scope.
+
+**Important Notes:** 
+- Key information about the class
+- Usage patterns and best practices
+
+### Function List
+- [functionName1](#functionname1) - Brief description
+- [functionName2](#functionname2) - Brief description
+
+### [functionName]
+Brief description of what this function does.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `param1` | `type` | Yes | Description |
+| `param2` | `type` | No | Description *(Optional)* |
+
+**Returns:** `ReturnType` - Description of what is returned
+
+**Usage Example:**
+```typescript
+// Example usage
+const result = await apiClient.methodName.functionName(param1, param2);
+```
+
+**Error Handling:**
+- Throws `Exception` when [condition]
+
+---
+
+## Navigation
+- [← Back to Main Documentation](../README.md)
+- [AssetMethods](./asset-methods.md)
+- [BatchMethods](./batch-methods.md)
+- [ContainerMethods](./container-methods.md)
+- [ContentMethods](./content-methods.md)
+- [InstanceMethods](./instance-methods.md)
+- [InstanceUserMethods](./instance-user-methods.md)
+- [ModelMethods](./model-methods.md)
+- [PageMethods](./page-methods.md)
+- [ServerUserMethods](./server-user-methods.md)
+- [WebhookMethods](./webhook-methods.md)
+```
+
+### Key Features to Highlight
+- **Modular Structure:** Easy navigation between method documentation
+- **Batch Methods:** Emphasize returnBatchId flags for advanced users
+- **Optional Parameters:** Clear indication of default values
+- **Return Types:** Precise type information
+- **Error Scenarios:** Common error conditions and handling
+- **Navigation:** Consistent cross-linking between all documentation files
+
+## Progress Tracking
+- **Total Functions:** 76 functions across 10 method classes
+- **Total Documentation Files:** 10 individual method documentation files + 1 main README
+- **Completed:** 2 files (Main README restructure + AssetMethods complete)
+- **Remaining:** 9 files (9 method docs remaining)
+- **Current Phase:** Phase 3 (BatchMethods Documentation)
+
+## Success Criteria
+- [ ] All 76 functions documented across 10 individual method files
+- [ ] Consistent formatting and navigation across all documentation files
+- [ ] Main README with clean method index and links to all documentation
+- [ ] Cross-linking navigation between all documentation files
+- [ ] All code examples tested and functional
+- [ ] Improved readability and developer experience with modular structure
+- [ ] Professional documentation structure following modern API documentation patterns 

package/.cursor/api-functions-analysis.md

@@ -0,0 +1,111 @@
+# API Functions Analysis - Actual Source Code
+
+## Complete Function Inventory
+
+### 1. AssetMethods (15 functions)
+- `deleteFile(mediaID: number, guid: string)`
+- `moveFile(mediaID: number, newFolder: string, guid: string)`
+- `getMediaList(pageSize: number, recordOffset: number, guid: string)`
+- `getGalleries(guid: string, search: string = null, pageSize: number = null, rowIndex: number = null)`
+- `getGalleryById(guid: string, id: number)`
+- `getGalleryByName(guid: string, galleryName: string)`
+- `getDefaultContainer(guid: string)`
+- `saveGallery(guid: string, gallery: assetMediaGrouping)`
+- `deleteGallery(guid: string, id: number)`
+- `getAssetByID(mediaID: number, guid: string)`
+- `getAssetByUrl(url: string, guid: string)`
+- `upload(formData: any, agilityFolderPath: string, guid: string, groupingID: number = -1)`
+- `createFolder(originKey: string, guid: string)`
+- `deleteFolder(originKey: string, guid: string, mediaID: number = 0)`
+- `renameFolder(folderName: string, newFolderName: string, guid: string, mediaID: number = 0)`
+
+### 2. BatchMethods (7 functions)
+- `getBatch(batchID: number, guid: string, expandItems: boolean = true)`
+- `publishBatch(batchID: number, guid: string, returnBatchId: boolean = false)`
+- `unpublishBatch(batchID: number, guid: string, returnBatchId: boolean = false)`
+- `approveBatch(batchID: number, guid: string, returnBatchId: boolean = false)`
+- `declineBatch(batchID: number, guid: string, returnBatchId: boolean = false)`
+- `requestApprovalBatch(batchID: number, guid: string, returnBatchId: boolean = false)`
+- `getBatchTypes(guid: string)`
+
+### 3. ContainerMethods (8 functions)
+- `getContainerByID(id: number, guid: string)`
+- `getContainersByModel(modelId: number, guid: string)`
+- `getContainerByReferenceName(referenceName: string, guid: string)`
+- `getContainerSecurity(id: number, guid: string)`
+- `getContainerList(guid: string)`
+- `getNotificationList(id: number, guid: string)`
+- `saveContainer(container: Container, guid: string, forceReferenceName: boolean = false)`
+- `deleteContainer(id: number, guid: string)`
+
+### 4. ContentMethods (13 functions)
+- `getContentItem(contentID: number, guid: string, locale: string)`
+- `publishContent(contentID: number, guid: string, locale: string, comments: string = null, returnBatchId: boolean = false)`
+- `unPublishContent(contentID: number, guid: string, locale: string, comments: string = null, returnBatchId: boolean = false)`
+- `contentRequestApproval(contentID: number, guid: string, locale: string, comments: string = null, returnBatchId: boolean = false)`
+- `approveContent(contentID: number, guid: string, locale: string, comments: string = null, returnBatchId: boolean = false)`
+- `declineContent(contentID: number, guid: string, locale: string, comments: string = null, returnBatchId: boolean = false)`
+- `deleteContent(contentID: number, guid: string, locale: string, comments: string = null, returnBatchId: boolean = false)`
+- `saveContentItem(contentItem: ContentItem, guid: string, locale: string, returnBatchId: boolean = false)`
+- `saveContentItems(contentItems: ContentItem[], guid: string, locale: string, returnBatchId: boolean = false)`
+- `getContentItems(referenceName: string, guid: string, locale: string, listParams: ListParams)`
+- `getContentList(referenceName: string, guid: string, locale: string, listParams: ListParams, filterObject: ContentListFilterModel = null)`
+- `getContentHistory(locale: string, guid: string, contentID: number, take: number = 50, skip: number = 0)`
+- `getContentComments(locale: string, guid: string, contentID: number, take: number = 50, skip: number = 0)`
+
+### 5. InstanceMethods (1 function)
+- `getLocales(guid: string)` - **ONLY ONE FUNCTION**
+
+### 6. InstanceUserMethods (3 functions)
+- `getUsers(guid: string)`
+- `saveUser(emailAddress: string, roles: InstanceRole[], guid: string, firstName: string = null, lastName: string = null)`
+- `deleteUser(userId: number, guid: string)`
+
+### 7. ModelMethods (6 functions)
+- `getContentModel(id: number, guid: string)`
+- `getModelByReferenceName(referenceName: string, guid: string)`
+- `getContentModules(includeDefaults: boolean, guid: string, includeModules: boolean = false)`
+- `getPageModules(includeDefault: boolean, guid: string)`
+- `saveModel(model: Model, guid: string)`
+- `deleteModel(id: number, guid: string)`
+
+### 8. PageMethods (17 functions)
+- `getSitemap(guid: string, locale: string)`
+- `getPageTemplates(guid: string, locale: string, includeModuleZones: boolean, searchFilter: string = null)`
+- `getPageTemplate(guid: string, locale: string, pageTemplateId: number)`
+- `getPageTemplateName(guid: string, locale: string, templateName: string)`
+- `deletePageTemplate(guid: string, locale: string, pageTemplateId: number)`
+- `getPageItemTemplates(guid: string, locale: string, id: number)`
+- `savePageTemplate(guid: string, locale: string, pageModel: PageModel)`
+- `getPage(pageID: number, guid: string, locale: string)`
+- `publishPage(pageID: number, guid: string, locale: string, comments: string = null, returnBatchId: boolean = false)`
+- `unPublishPage(pageID: number, guid: string, locale: string, comments: string = null, returnBatchId: boolean = false)`
+- `pageRequestApproval(pageID: number, guid: string, locale: string, comments: string = null, returnBatchId: boolean = false)`
+- `approvePage(pageID: number, guid: string, locale: string, comments: string = null, returnBatchId: boolean = false)`
+- `declinePage(pageID: number, guid: string, locale: string, comments: string = null, returnBatchId: boolean = false)`
+- `deletePage(pageID: number, guid: string, locale: string, comments: string = null, returnBatchId: boolean = false)`
+- `savePage(pageItem: PageItem, guid: string, locale: string, parentPageID: number = -1, placeBeforePageItemID: number = -1, returnBatchId: boolean = false)`
+- `getPageHistory(locale: string, guid: string, pageID: number, take: number = 50, skip: number = 0)`
+- `getPageComments(locale: string, guid: string, pageID: number, take: number = 50, skip: number = 0)`
+
+### 9. ServerUserMethods (2 functions)
+- `me(guid: string)`
+- `you(guid: string, serverUserID: number)`
+
+### 10. WebhookMethods (4 functions)
+- `webhookList(guid: string, take: number = 20, token: string = null)`
+- `saveWebhook(guid: string, webhook: Webhook)`
+- `getWebhook(guid: string, webhookID: string)`
+- `deleteWebhook(guid: string, webhookID: string)`
+
+## Total Functions: 76
+
+## Corrections Needed
+- **ContentMethods**: I hallucinated functions like `getContentItemByLanguageCode`, `getContentItemHistory`, `getContentItemComments`, `getContentListByContainer`, etc.
+- **InstanceMethods**: I hallucinated `getInstanceUsers` when the only function is `getLocales`
+- Several parameter orders and types were incorrect
+
+## Next Steps
+1. Fix ContentMethods documentation completely
+2. Fix InstanceMethods documentation completely
+3. Verify other documentation files match actual source code 

package/.cursor/breakout-manifest.md

@@ -0,0 +1,278 @@
+# Auth Tools Package Breakout Manifest
+
+## Overview
+
+Extract authentication-related components from `agility-cms-management-sdk-typescript` into a separate `agilitycms-management-sdk-auth-tools` package to create a focused, reusable authentication toolkit.
+
+## Analysis Summary
+
+### Files to Move
+
+#### React Components & Hooks
+- `src/components/auth/AgilityAuth.tsx` (844 lines) - Main auth component
+- `src/components/auth/TokenInfoModal.tsx` (133 lines) - Debug modal
+- `src/components/auth/context/AuthContext.tsx` (266 lines) - Auth context provider
+- `src/components/auth/hooks/useAgilityAuth.ts` (329 lines) - Main auth hook
+- `src/components/auth/hooks/useWebsiteSelection.ts` (150 lines) - Website selection hook
+- `src/components/auth/index.ts` (12 lines) - Component exports
+
+#### Authentication Methods
+- `src/clientMethods/authMethods.ts` (507 lines) - OAuth & token management
+- `src/tokenStorage.ts` (305 lines) - Secure token storage
+
+#### Models & Types
+- `src/models/authComponent.ts` (102 lines) - Component interfaces
+- `src/models/authConfig.ts` (276 lines) - Configuration interfaces
+- `src/models/authState.ts` (207 lines) - State management types
+- `src/models/authTokens.ts` (80 lines) - OAuth token types
+
+#### Dependencies to Keep in Main SDK
+- `src/models/serverUser.ts` - Required by auth but also by main SDK
+- `src/models/websiteListing.ts` - Used by auth components
+- `src/models/options.ts` - Shared configuration
+- `src/models/exception.ts` - Error handling
+- `src/apiMethods/clientInstance.ts` - HTTP client (partial dependency)
+
+---
+
+## Phase Breakdown
+
+### Phase 1: New Package Setup (Parallel Execution)
+**Goal**: Create independent package structure with proper configuration
+
+#### Tasks:
+1. **Package Structure** (Task 1A)
+   - Create `../agilitycms-management-sdk-auth-tools/` directory
+   - Set up `package.json` with proper dependencies
+   - Configure TypeScript (`tsconfig.json`)
+   - Set up build scripts and npm configuration
+   - Create README and documentation structure
+
+2. **Dependencies Analysis** (Task 1B)
+   - Map React dependencies (`react`, `react-dom`, `lucide-react`)
+   - Identify shared models that need to be duplicated or abstracted
+   - Plan interface contracts between packages
+   - Define peer dependency requirements
+
+3. **Build Configuration** (Task 1C)
+   - Configure TypeScript compilation
+   - Set up ESM/CJS dual build
+   - Configure bundling for browser compatibility
+   - Set up development build tools
+
+---
+
+### Phase 2: Model & Type Migration (Sequential within, Parallel between)
+**Goal**: Move and adapt all authentication-related types and models
+
+#### Tasks:
+2. **Core Models** (Task 2A) - *Depends on 1A*
+   - Move `authComponent.ts`, `authConfig.ts`, `authState.ts`, `authTokens.ts`
+   - Create local copies of required shared models (`serverUser.ts`, `exception.ts`)
+   - Update import paths within auth models
+   - Define external interfaces for main SDK integration
+
+3. **Shared Dependencies** (Task 2B) - *Depends on 2A*
+   - Create abstracted interfaces for `Options` integration
+   - Define `ClientInstance` interface contract
+   - Create minimal `Exception` handling for auth package
+   - Plan SDK integration points
+
+---
+
+### Phase 3: Core Authentication Logic (Sequential)
+**Goal**: Move authentication methods and token management
+
+#### Tasks:
+4. **Token Storage** (Task 3A) - *Depends on 2B*
+   - Move `tokenStorage.ts` to new package
+   - Update keytar dependencies
+   - Test cross-platform compatibility
+   - Ensure browser/Node.js environment handling
+
+5. **Auth Methods** (Task 3B) - *Depends on 3A*
+   - Move `authMethods.ts` to new package
+   - Abstract `ClientInstance` dependencies
+   - Create OAuth flow handlers
+   - Implement token refresh logic
+   - Define integration interface for main SDK
+
+---
+
+### Phase 4: React Components Migration (Parallel Execution)
+**Goal**: Move all React components and hooks to new package
+
+#### Tasks:
+6. **Context & State Management** (Task 4A) - *Depends on 2A*
+   - Move `AuthContext.tsx` and related hooks
+   - Update import paths for new models
+   - Test state management isolation
+   - Ensure proper React context boundaries
+
+7. **Core Components** (Task 4B) - *Depends on 4A, 3B*
+   - Move `AgilityAuth.tsx` main component
+   - Move `TokenInfoModal.tsx` debug component
+   - Update all imports to new package paths
+   - Test component integration with auth methods
+
+8. **Hooks & Utilities** (Task 4C) - *Depends on 4A, 3B*
+   - Move `useAgilityAuth.ts` and `useWebsiteSelection.ts`
+   - Update hook dependencies and imports
+   - Test hook functionality with new auth methods
+   - Ensure proper TypeScript integration
+
+---
+
+### Phase 5: Package Integration (Sequential)
+**Goal**: Connect new package back to main SDK and update exports
+
+#### Tasks:
+9. **Main SDK Updates** (Task 5A) - *Depends on 4B, 4C*
+   - Remove auth exports from main `src/index.ts`
+   - Remove auth components and methods from main package
+   - Update `package.json` to include new auth package as dependency
+   - Clean up unused files and imports
+
+10. **Integration Interface** (Task 5B) - *Depends on 5A, 3B*
+    - Create SDK adapter for auth package integration
+    - Implement `ApiClient` auth method delegation
+    - Ensure `authMethods` still works from main SDK
+    - Maintain backward compatibility for existing users
+
+11. **Export Configuration** (Task 5C) - *Depends on 5B*
+    - Configure new package exports (`package.json` exports field)
+    - Set up proper TypeScript declaration files
+    - Test import/export functionality
+    - Document new usage patterns
+
+---
+
+### Phase 6: Testing & Documentation (Parallel Execution)
+**Goal**: Verify functionality and provide comprehensive documentation
+
+#### Tasks:
+12. **Integration Testing** (Task 6A) - *Depends on 5C*
+    - Test OAuth flow from new package
+    - Verify token storage functionality
+    - Test React component integration
+    - Ensure cross-platform compatibility (browser/Node.js)
+
+13. **Backward Compatibility** (Task 6B) - *Depends on 5C*
+    - Verify existing SDK usage patterns still work
+    - Test re-export functionality from main SDK
+    - Ensure no breaking changes for current users
+    - Create migration guide for advanced users
+
+14. **Documentation** (Task 6C) - *Can run in parallel with other Phase 6 tasks*
+    - Create comprehensive README for auth package
+    - Document component props and configuration options
+    - Create usage examples and tutorials
+    - Update main SDK documentation to reference auth package
+
+---
+
+## Key Dependencies & Critical Paths
+
+### Critical Path Analysis:
+1. **Package Setup** → **Models** → **Auth Methods** → **Components** → **Integration** → **Testing**
+2. Longest path: ~7 sequential dependencies
+3. Significant parallelization opportunities in Phases 1, 4, and 6
+
+### Shared Dependencies Resolution:
+- **ServerUser**: Copy interface to auth package, maintain compatibility
+- **Options**: Create abstract interface, implement adapter pattern
+- **ClientInstance**: Extract HTTP interface, implement in both packages
+- **Exception**: Create minimal version for auth package
+
+### Risk Mitigation:
+- **Token Storage**: Test extensively across platforms
+- **React Integration**: Ensure hooks work independently
+- **TypeScript**: Maintain strict type safety across package boundaries
+- **Build System**: Test both development and production builds
+
+---
+
+## Success Criteria
+
+### Phase Completion Criteria:
+1. ✅ New package builds successfully with all dependencies
+2. ✅ All authentication components work independently
+3. ✅ Main SDK maintains backward compatibility
+4. ✅ OAuth flow works end-to-end from new package
+5. ✅ Token storage works across all supported platforms
+6. ✅ TypeScript types are properly exported and imported
+7. ✅ Documentation is comprehensive and accurate
+
+### Quality Gates:
+- All existing tests pass after migration
+- No breaking changes for current SDK users
+- New package follows semantic versioning
+- All React components render without errors
+- OAuth flow completes successfully in browser environment
+- Token storage works in both Node.js and browser
+- TypeScript compilation succeeds with strict settings
+
+---
+
+## Package Structure Preview
+
+```
+agilitycms-management-sdk-auth-tools/
+├── package.json                    # New auth package config
+├── tsconfig.json                   # TypeScript configuration
+├── README.md                       # Package documentation
+├── src/
+│   ├── index.ts                    # Main package exports
+│   ├── components/                 # React components
+│   │   ├── AgilityAuth.tsx
+│   │   ├── TokenInfoModal.tsx
+│   │   ├── context/
+│   │   │   └── AuthContext.tsx
+│   │   └── hooks/
+│   │       ├── useAgilityAuth.ts
+│   │       └── useWebsiteSelection.ts
+│   ├── auth/                       # Authentication logic
+│   │   ├── authMethods.ts
+│   │   └── tokenStorage.ts
+│   ├── models/                     # Type definitions
+│   │   ├── authComponent.ts
+│   │   ├── authConfig.ts
+│   │   ├── authState.ts
+│   │   ├── authTokens.ts
+│   │   ├── serverUser.ts           # Local copy
+│   │   └── shared.ts               # Shared interfaces
+│   └── adapters/                   # SDK integration
+│       └── sdkAdapter.ts
+├── dist/                          # Built package
+└── docs/                          # Package documentation
+```
+
+---
+
+## Execution Strategy
+
+### Development Approach:
+1. **Create Feature Branch**: `feature/auth-package-breakout`
+2. **Incremental Development**: Complete phases in order, test at each step
+3. **Parallel Work**: Leverage task parallelization within phases
+4. **Quality Gates**: Don't proceed to next phase until current phase passes all criteria
+5. **Continuous Testing**: Run tests after each major change
+
+### Timeline Estimate:
+- **Phase 1**: 2-3 hours (setup and configuration)
+- **Phase 2**: 1-2 hours (models and types)
+- **Phase 3**: 2-3 hours (auth methods and token storage)
+- **Phase 4**: 3-4 hours (React components)
+- **Phase 5**: 2-3 hours (integration)
+- **Phase 6**: 2-3 hours (testing and documentation)
+
+**Total Estimated Time**: 12-18 hours
+
+### Resource Requirements:
+- Single developer can execute most tasks
+- Some testing may benefit from multiple environment validation
+- Documentation can be parallelized if resources available
+
+---
+
+*This manifest will be updated as phases complete and new requirements are discovered.*