@cdmbase/wiki-browser 12.0.18-alpha.5

package/lib/templates/content/docs/adminide-modules/preferences/UI-components/ResourceSettingsLoader.md

@@ -0,0 +1,319 @@
+# ResourceSettingsLoader Usage Guide
+
+This guide explains how to use `ResourceSettingsLoader` component, which leverages `useSettingsLoader` hook to fetch configuration data from Remix loaders.
+
+## Overview
+
+`ResourceSettingsLoader` is a component that displays and manages settings/configuration data. Unlike `ResourceSettings` which requires you to pass the `input` (preferencesInput) prop directly, `ResourceSettingsLoader` automatically retrieves the configuration and preferencesInput from the Remix loader data based on the `schemaId` you provide.
+
+## Key Differences: ResourceSettings vs ResourceSettingsLoader
+
+| Feature          | ResourceSettings                      | ResourceSettingsLoader                             |
+| ---------------- | ------------------------------------- | -------------------------------------------------- |
+| Data Source      | Direct Apollo query via `useSettings` | Remix loader data via `useSettingsLoader`          |
+| Input Prop       | Required - must pass `input` prop     | Optional - auto-resolves from loader by `schemaId` |
+| Network Requests | Makes GraphQL query on mount          | Uses SSR-loaded data, no extra requests            |
+| Configuration    | Fetches on client                     | Pre-fetched during SSR/navigation                  |
+
+## Prerequisites: Route Configuration with extraParams
+
+For `ResourceSettingsLoader` to work correctly, your route configuration must include `extraParams.resourceParams` with the appropriate `schemaId`. This tells the middleware which configurations to pre-fetch during SSR.
+
+### Example Route Configuration
+
+```typescript
+// In your route module (e.g., compute.ts)
+import { ConfigCollectionName, ConfigFragmentName, ContributionSchemaId } from 'common';
+
+export const routes: IRouteModule[] = [
+    {
+        name: 'menu.policy',
+        key: 'pref-policy-view',
+        tab: 'Policy View',
+        path: '/org/:orgName/preferences/policies',
+        auth: true,
+        authority: [PreDefineAccountPermissions.editPolicies],
+        component: () => import('./policies/OrganizationPolicies'),
+        // IMPORTANT: extraParams tells the middleware what to pre-fetch
+        extraParams: {
+            resourceParams: [
+                // First: Default configuration schema (optional but recommended)
+                {
+                    fragment: ConfigFragmentName.Settings,
+                    query: { name: '$params.orgName' },
+                    path: ConfigCollectionName.Organizations,
+                    resourceType: ConfigCollectionName.Organizations,
+                    resourceId: 'name:$params.orgName',
+                    organization: '$params.orgName',
+                    options: {
+                        configKey: '',
+                        schemaId: ContributionSchemaId.Configuration,
+                    },
+                },
+                // Second: Policy schema (the one we want to display)
+                {
+                    fragment: ConfigFragmentName.Policies,
+                    query: { name: '$params.orgName' },
+                    path: ConfigCollectionName.Organizations,
+                    resourceType: ConfigCollectionName.Organizations,
+                    resourceId: 'name:$params.orgName',
+                    organization: '$params.orgName',
+                    options: {
+                        configKey: '',
+                        schemaId: ContributionSchemaId.Policy, // <-- This schema will be available
+                    },
+                },
+            ],
+        },
+    },
+];
+```
+
+### Key Points for Route Configuration
+
+1. **`$params.orgName`**: Use `$params.xxx` placeholders to reference URL parameters. These are resolved by the middleware.
+
+2. **Multiple resourceParams**: You can specify multiple schemas. Each will be fetched and stored in:
+    - `configurationsBySchemaId[schemaId]` - the configuration data
+    - `preferencesInputBySchemaId[schemaId]` - the input needed for mutations
+
+3. **schemaId in options**: The `options.schemaId` determines which schema bucket the data goes into.
+
+## Using ResourceSettingsLoader Component
+
+### Basic Usage
+
+```tsx
+import { ResourceSettingsLoader } from '@adminide-stack/platform-browser/lib/tailwind-module/components/SettingsEditor/ResourceSettingsLoader.js';
+import { ConfigurationTarget, ContributionSchemaId } from 'common';
+
+export default function OrganizationPolicies() {
+    return (
+        <ResourceSettingsLoader
+            target={ConfigurationTarget.ORGANIZATION}
+            preferences={preferences} // Array of IContributionSettings (schema definitions)
+            schemaId={ContributionSchemaId.Policy} // Must match the schemaId in route extraParams
+            showSidebar={true}
+            hasPermission={true}
+        />
+    );
+}
+```
+
+### With Suspense and Loader Data (Recommended Pattern)
+
+```tsx
+import * as React from 'react';
+import { Await, useLoaderData } from '@remix-run/react';
+import { ResourceSettingsLoader } from '@adminide-stack/platform-browser/lib/tailwind-module/components/SettingsEditor/ResourceSettingsLoader.js';
+import { ConfigurationTarget, ContributionSchemaId } from 'common';
+
+export default function OrganizationPolicies() {
+    const loaderData = useLoaderData();
+
+    return (
+        <div className="themed-card shadow-themed-sm">
+            <React.Suspense fallback={<LoadingSpinner />}>
+                <Await resolve={loaderData.defaultResolveSettingsQuery}>
+                    {(data) => (
+                        <WithPermissionByLoader
+                            permissionKeys={[PreDefineAccountPermissions.editPolicies]}
+                            render={({ hasPermission }) => (
+                                <ResourceSettingsLoader
+                                    target={ConfigurationTarget.ORGANIZATION}
+                                    preferences={data.data.resolveSettings || []}
+                                    schemaId={ContributionSchemaId.Policy}
+                                    showSidebar={true}
+                                    hasPermission={hasPermission}
+                                />
+                            )}
+                        />
+                    )}
+                </Await>
+            </React.Suspense>
+        </div>
+    );
+}
+```
+
+## Props Reference
+
+| Prop                 | Type                      | Required | Default      | Description                                                          |
+| -------------------- | ------------------------- | -------- | ------------ | -------------------------------------------------------------------- |
+| `target`             | `ConfigurationTarget`     | Yes      | -            | Where to save settings (ORGANIZATION, USER, etc.)                    |
+| `preferences`        | `IContributionSettings[]` | Yes      | -            | Schema definitions for the settings UI                               |
+| `schemaId`           | `string`                  | No       | -            | Schema ID to fetch from loader (e.g., `ContributionSchemaId.Policy`) |
+| `showSidebar`        | `boolean`                 | Yes      | -            | Whether to show the settings sidebar                                 |
+| `hasPermission`      | `boolean`                 | No       | -            | Whether user can edit settings                                       |
+| `input`              | `IPreferencesInputInput`  | No       | -            | Override preferencesInput (auto-resolved if not provided)            |
+| `configKey`          | `string`                  | No       | `''`         | Specific config key to fetch                                         |
+| `resourceUri`        | `any`                     | No       | -            | Specific resource URI to query                                       |
+| `includeMarketplace` | `boolean`                 | No       | `false`      | Include marketplace configurations                                   |
+| `type`               | `string`                  | No       | `'settings'` | Type of settings fragment                                            |
+
+## How It Works
+
+### Data Flow
+
+```
+1. Route Navigation
+   ↓
+2. Middleware reads extraParams.resourceParams
+   ↓
+3. configurationLoader fetches data for each schemaId
+   ↓
+4. Data stored in loader response:
+   - configurations (primary)
+   - configurationsBySchemaId[schemaId]
+   - preferencesInputBySchemaId[schemaId]
+   ↓
+5. ResourceSettingsLoader uses useSettingsLoader hook
+   ↓
+6. useSettingsLoader reads from loader data by schemaId
+   ↓
+7. Component renders with pre-fetched data
+```
+
+### useSettingsLoader Hook (Internal)
+
+The `ResourceSettingsLoader` internally uses `useSettingsLoader`:
+
+```typescript
+const {
+    updateConfiguration,
+    data: configData,
+    loading,
+    preferencesInput,
+} = useSettingsLoader({
+    configKey: '',
+    schemaId: ContributionSchemaId.Policy, // Reads from configurationsBySchemaId['policy']
+    resourceUri: undefined,
+    includeMarketplace: false,
+});
+```
+
+The hook:
+
+1. Reads `useLoaderData()` from Remix
+2. If `schemaId` is provided, looks in `configurationsBySchemaId[schemaId]`
+3. Also retrieves `preferencesInputBySchemaId[schemaId]` for mutations
+4. Returns data without making additional network requests
+
+## Available Schema IDs
+
+```typescript
+export const enum ContributionSchemaId {
+    Configuration = 'configuration', // Default settings
+    Policy = 'policy', // Organization policies
+    Permission = 'permission', // Permissions
+    UiLayout = 'uiLayout', // UI layout configurations
+    // ... add more as needed
+}
+```
+
+## Common Patterns
+
+### Pattern 1: Single Schema (e.g., Policies Only)
+
+```typescript
+// Route config
+extraParams: {
+    resourceParams: {
+        fragment: ConfigFragmentName.Policies,
+        options: { schemaId: ContributionSchemaId.Policy },
+        // ... other params
+    },
+}
+
+// Component
+<ResourceSettingsLoader
+    schemaId={ContributionSchemaId.Policy}
+    // ...
+/>
+```
+
+### Pattern 2: Multiple Schemas (e.g., Settings + UiLayout)
+
+```typescript
+// Route config
+extraParams: {
+    resourceParams: [
+        {
+            fragment: ConfigFragmentName.Settings,
+            options: { schemaId: ContributionSchemaId.Configuration },
+            // ...
+        },
+        {
+            fragment: ConfigFragmentName.UiSettings,
+            options: { schemaId: ContributionSchemaId.UiLayout },
+            // ...
+        },
+    ],
+}
+
+// Component - use the schema you need
+<ResourceSettingsLoader
+    schemaId={ContributionSchemaId.UiLayout}
+    // ...
+/>
+```
+
+### Pattern 3: Fallback to Default Configuration
+
+If you don't provide a `schemaId`, the component uses the primary `configurations` from the loader:
+
+```typescript
+<ResourceSettingsLoader
+    target={ConfigurationTarget.ORGANIZATION}
+    preferences={preferences}
+    showSidebar={true}
+    // No schemaId - uses default configurations
+/>
+```
+
+## Troubleshooting
+
+### Configuration data is empty
+
+1. **Check route extraParams**: Ensure your route has `extraParams.resourceParams` with the correct `schemaId`
+2. **Verify $params placeholders**: Make sure placeholders like `$params.orgName` match your URL parameters
+3. **Check middleware order**: Ensure `configurationMiddleware` runs after `lifecycleMiddleware`
+
+### preferencesInput is undefined
+
+1. **Check schemaId match**: The `schemaId` prop must match the `options.schemaId` in route config
+2. **Verify loader data**: Check browser DevTools → Network → loader response
+
+### Settings not saving
+
+1. **Check target**: Ensure `target` prop matches your expected save location
+2. **Verify permissions**: Check that `hasPermission` is true
+3. **Check preferencesInput.editableSettingsInput**: This is used for the mutation
+
+## Migration from ResourceSettings
+
+Before (ResourceSettings):
+
+```tsx
+<ResourceSettings
+    target={ConfigurationTarget.ORGANIZATION}
+    preferences={preferences}
+    input={loaderData.dataContext?.preferencesInputBySchemaId[ContributionSchemaId.Policy]}
+    showSidebar={true}
+    hasPermission={hasPermission}
+/>
+```
+
+After (ResourceSettingsLoader):
+
+```tsx
+<ResourceSettingsLoader
+    target={ConfigurationTarget.ORGANIZATION}
+    preferences={preferences}
+    schemaId={ContributionSchemaId.Policy} // Auto-resolves input
+    showSidebar={true}
+    hasPermission={hasPermission}
+/>
+```
+
+The key change: Replace `input` prop with `schemaId` prop. The component handles the rest.

package/lib/templates/content/docs/adminide-modules/preferences/contribute_scope_target.md

@@ -0,0 +1,280 @@
+# Configuration Scope and Target Documentation
+
+This document explains how `ConfigurationScope` and `ConfigurationTarget` work in the configuration system, and how they interact to determine which settings are available at different levels of the application hierarchy.
+
+## Overview
+
+The configuration system uses two related but distinct concepts:
+
+1. **ConfigurationScope** - Defines _where_ a configuration property can be set (its "settability")
+2. **ConfigurationTarget** - Defines _which_ configuration file/level is being read from or written to
+
+## ConfigurationScope
+
+`ConfigurationScope` is assigned to each configuration property when it's defined. It determines at which levels that property can be configured.
+
+### Scope Values
+
+| Scope                  | Value | Description                                                                                               |
+| ---------------------- | ----- | --------------------------------------------------------------------------------------------------------- |
+| `APPLICATION`          | 1     | Application-specific configuration. Can only be configured in local user settings.                        |
+| `MACHINE`              | 2     | Machine-specific configuration. Can only be configured in local and remote user settings.                 |
+| `WINDOW`               | 3     | Window-specific configuration. Can be configured in user or organization settings.                        |
+| `RESOURCE`             | 4     | Resource-specific configuration. Can be configured in user, organization, or resource/workspace settings. |
+| `RESOURCE_OVERRIDABLE` | 5     | Resource-specific configuration that can be overridden at multiple levels.                                |
+| `MACHINE_OVERRIDABLE`  | 6     | Machine-specific configuration that can also be overridden.                                               |
+
+### Scope Hierarchy
+
+Scopes follow an inheritance pattern where higher-level scopes can cascade down:
+
+```
+APPLICATION (1)
+     ↓
+  MACHINE (2)
+     ↓
+  WINDOW (3)      ← Most common for organization-level settings
+     ↓
+  RESOURCE (4)    ← Most specific, can be set at resource/workspace level
+```
+
+### Scope Collections
+
+The system defines pre-built scope collections for common use cases:
+
+```typescript
+// User-level scopes
+USER_SCOPES = [APPLICATION];
+
+// Local machine scopes
+LOCAL_MACHINE_SCOPES = [APPLICATION, WINDOW, RESOURCE];
+
+// Remote machine scopes
+REMOTE_MACHINE_SCOPES = [MACHINE, WINDOW, RESOURCE];
+
+// Organization-level scopes
+ORGANIZATION_SCOPES = [WINDOW, RESOURCE];
+
+// Resource-level scopes
+RESOURCE_SCOPES = [RESOURCE];
+```
+
+## ConfigurationTarget
+
+`ConfigurationTarget` specifies which configuration file or level is being accessed when reading or writing configuration values.
+
+### Target Values
+
+| Target                  | Value | Description                                                     |
+| ----------------------- | ----- | --------------------------------------------------------------- |
+| `USER`                  | 1     | User/application configuration file                             |
+| `APPLICATION`           | 2     | Application configuration file                                  |
+| `MACHINE`               | 3     | Machine configuration file (requires machine context)           |
+| `ORGANIZATION`          | 4     | Organization configuration file (requires organization context) |
+| `ORGANIZATION_RESOURCE` | 5     | Resource configuration within an organization                   |
+| `DEFAULT`               | 6     | Default configuration (system defaults)                         |
+| `MEMORY`                | 7     | In-memory configuration (not persisted)                         |
+| `RESOURCE_OVERRIDABLE`  | 8     | Resource configuration that can be overridden                   |
+| `MACHINE_OVERRIDABLE`   | 9     | Machine configuration that can be overridden                    |
+
+## Target-to-Scope Mapping
+
+When querying configurations for a specific target, only properties with matching scopes are returned. This mapping is defined in `getScopesForTarget()`:
+
+| Target                                         | Allowed Scopes                             | Description                                |
+| ---------------------------------------------- | ------------------------------------------ | ------------------------------------------ |
+| `USER`                                         | `[APPLICATION]`                            | Only application-scoped properties         |
+| `APPLICATION`                                  | `[APPLICATION, WINDOW, RESOURCE]`          | All local-configurable properties          |
+| `MACHINE`                                      | `[MACHINE, WINDOW, RESOURCE]`              | Machine and lower-level properties         |
+| `ORGANIZATION`                                 | `[WINDOW, RESOURCE]`                       | Organization-level and resource properties |
+| `ORGANIZATION_RESOURCE`                        | `[RESOURCE]`                               | Only resource-scoped properties            |
+| `DEFAULT` / `MEMORY`                           | `[APPLICATION, MACHINE, WINDOW, RESOURCE]` | All scopes (complete view)                 |
+| `RESOURCE_OVERRIDABLE` / `MACHINE_OVERRIDABLE` | `[MACHINE, WINDOW, RESOURCE]`              | Overridable properties                     |
+
+## How Scope Filtering Works
+
+### Example: Defining a Configuration Property
+
+When defining a configuration property in a contribution file:
+
+```typescript
+// This property can be set at organization level or resource level
+{
+    'myExtension.featureEnabled': {
+        type: 'boolean',
+        default: true,
+        scope: ConfigurationScope.WINDOW,  // ← Settable at WINDOW level and above
+        description: 'Enable my feature'
+    }
+}
+
+// This property can ONLY be set at resource level
+{
+    'myExtension.resourceSetting': {
+        type: 'string',
+        default: 'default',
+        scope: ConfigurationScope.RESOURCE,  // ← Only settable at RESOURCE level
+        description: 'Resource-specific setting'
+    }
+}
+```
+
+### Example: Querying Configuration
+
+When querying with different targets:
+
+```typescript
+// Query with target=4 (ORGANIZATION)
+// Returns properties with scope: WINDOW or RESOURCE
+pageSettings({ target: ConfigurationTarget.ORGANIZATION });
+// Result: includes 'myExtension.featureEnabled' and 'myExtension.resourceSetting'
+
+// Query with target=5 (ORGANIZATION_RESOURCE)
+// Returns ONLY properties with scope: RESOURCE
+pageSettings({ target: ConfigurationTarget.ORGANIZATION_RESOURCE });
+// Result: includes only 'myExtension.resourceSetting'
+// 'myExtension.featureEnabled' is EXCLUDED because it has scope: WINDOW
+```
+
+## Configuration Cascade Flow
+
+When resolving the final value for a configuration property, the system merges values from multiple levels:
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                        DEFAULT                                   │
+│  (System defaults from contribution files)                       │
+└───────────────────────────┬─────────────────────────────────────┘
+                            ↓
+┌─────────────────────────────────────────────────────────────────┐
+│                     APPLICATION                                  │
+│  (Application-level settings)                                    │
+└───────────────────────────┬─────────────────────────────────────┘
+                            ↓
+┌─────────────────────────────────────────────────────────────────┐
+│                         USER                                     │
+│  (User-specific settings)                                        │
+└───────────────────────────┬─────────────────────────────────────┘
+                            ↓
+┌─────────────────────────────────────────────────────────────────┐
+│                      ORGANIZATION                                │
+│  (Organization-level settings - scope: WINDOW, RESOURCE)        │
+└───────────────────────────┬─────────────────────────────────────┘
+                            ↓
+┌─────────────────────────────────────────────────────────────────┐
+│                  ORGANIZATION_RESOURCE                           │
+│  (Resource-level settings - scope: RESOURCE only)               │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**Merge Order**: Later levels override earlier levels. A value set at `ORGANIZATION_RESOURCE` takes precedence over the same key set at `ORGANIZATION`.
+
+## Common Use Cases
+
+### 1. Organization-Wide Settings
+
+For settings that apply across an entire organization:
+
+```typescript
+{
+    'organization.theme': {
+        type: 'string',
+        default: 'light',
+        scope: ConfigurationScope.WINDOW,  // Settable at organization level
+        description: 'Organization-wide theme'
+    }
+}
+```
+
+### 2. Resource-Specific Settings
+
+For settings that can vary per resource/workspace:
+
+```typescript
+{
+    'workspace.buildCommand': {
+        type: 'string',
+        default: 'npm run build',
+        scope: ConfigurationScope.RESOURCE,  // Settable at resource level
+        description: 'Build command for this workspace'
+    }
+}
+```
+
+### 3. Application-Only Settings
+
+For settings that should only be set at the application level:
+
+```typescript
+{
+    'app.telemetryEnabled': {
+        type: 'boolean',
+        default: true,
+        scope: ConfigurationScope.APPLICATION,  // Only at application level
+        description: 'Enable telemetry'
+    }
+}
+```
+
+## API Usage
+
+### Reading Configuration
+
+```typescript
+// Get configuration for organization level
+const orgConfig = await pageSettings({
+    uri: cdecodeUri,
+    options: {
+        target: ConfigurationTarget.ORGANIZATION, // target: 4
+    },
+});
+
+// Get configuration for resource level
+const resourceConfig = await pageSettings({
+    uri: cdecodeUri,
+    options: {
+        target: ConfigurationTarget.ORGANIZATION_RESOURCE, // target: 5
+    },
+});
+```
+
+### Writing Configuration
+
+```typescript
+// Write to organization level
+await writeSettings(
+    editingUri,
+    { 'myExtension.featureEnabled': false },
+    overrides,
+    ConfigurationTarget.ORGANIZATION,
+    false,
+    schemaId,
+);
+
+// Write to resource level
+await writeSettings(
+    editingUri,
+    { 'myExtension.resourceSetting': 'custom-value' },
+    overrides,
+    ConfigurationTarget.ORGANIZATION_RESOURCE,
+    false,
+    schemaId,
+);
+```
+
+## Important Notes
+
+1. **Scope defines settability, not visibility**: A property with `scope: RESOURCE` can only be _set_ at resource level, but its value is still _visible_ when querying at higher levels.
+
+2. **Empty results at ORGANIZATION_RESOURCE**: If you query with `target: ORGANIZATION_RESOURCE` (5) and get empty results, it's likely because your properties are defined with `scope: WINDOW` instead of `scope: RESOURCE`.
+
+3. **Default configuration and targets**: When fetching `DefaultConfiguration`, the target affects which properties are included based on their scope. This is intentional to show only the settings that can actually be modified at that level.
+
+4. **Caching**: Configuration properties are cached per target. Different targets will have separate cache entries to ensure scope-filtered results are properly cached.
+
+## File Locations
+
+- **Scope definitions**: `packages/adminide-core/src/interfaces/configuration/configuration.ts`
+- **Target definitions**: `packages/common/src/configuration.ts`
+- **Scope-to-Target mapping**: `packages/adminide-platform/server/src/utils/getScope.ts`
+- **Scope matching logic**: `packages/adminide-platform/server/src/core/configuration/default-settings/configurationHelpers.ts`

package/lib/templates/content/docs/adminide-modules/preferences/generate-urii.md

@@ -0,0 +1,94 @@
+---
+meta:
+    title: Generate URI
+    description: Generate URI
+date: '2023-06-02T00:00:00'
+updated: '2024-06-02T00:00:00'
+excerpt: Generate URI...
+headers:
+    Cache-Control: no-cache
+---
+
+## Generate URI
+
+Use `generateUri` from `@adminide-stack/core`.
+
+params of the URI's query should be `sorted` in order which the above function does it automatically.
+
+### To generate organization URI
+
+Another helpful function, if generating `orgUri`.
+
+```
+const orgUri = generateOrgUri(orgName, IConfigFragmentName.settings);
+
+```
+
+### To generate User URI
+
+In the frontend, we can pass userId as `self` as there are methods to replace with right value.
+
+```
+import {
+  IClientCacheTypeNames,
+  generateResourceUri,
+  IConfigCollectionName,
+  TeamContextFragmentDoc,
+} from '@adminide-stack/core';
+
+const userProxyURI = generateUserUri('self'); // we don't give `params` in the client side.
+```
+
+If you want to generate User resource URI to use in `backend service` from a given user's `alias`.
+
+```
+  const generatedUserUri = generateResourceUri(
+                        IConfigCollectionName.accounts,
+                        {alias: [user.auth0UserId]} as any,
+                        IConfigFragmentName.settings,
+                    )
+```
+
+### To generate Resource URI
+
+```
+import {
+  IClientCacheTypeNames,
+  generateResourceUri,
+  IConfigCollectionName,
+  TeamContextFragmentDoc,
+} from '@adminide-stack/core';
+
+const teamUri = generateResourceUri(
+        IConfigCollectionName.teams,
+        { name: teamName, orgName },
+        IConfigFragmentName.settings,
+      );
+```
+
+## Fragment name to generate Permission/Policy/Settings URI
+
+`IConfigFragmentName` name that is given based on type of URI you want to generate.
+
+For Settings URI: use `IConfigFragmentName.settings`
+For Permission URI: use `IConfigFragmentName.permissions`
+FOr Policy URI: use `IConfigFragmentName.Policy`
+
+## Params in the generateURI
+
+Except for OrgURI, rest of the URIs such as UserUri, TeamURI, ProjectURI, ClientURI need to pass `Collection Name` and `Params to filter the resource id`
+
+### Collection mapping
+
+Here are following collections avaialble based on the resource URI.
+
+```
+enum IConfigCollectionName {
+    accounts = "accounts",
+    organizations = "organizations",
+    workspaces = "workspaces",
+    teams = "teams",
+    projects = "projects",
+    clients = "clients"
+}
+```