@adminide-stack/marketplace-module-server 12.0.4-alpha.95 → 13.0.1-alpha.0

package/lib/templates/repositories/MarketplacePublisherRepository.ts.template

@@ -0,0 +1,24 @@
+import { IBaseMongoRepository, IMarketplacePublisherModel, AsDomainType } from 'common/server';
+
+export interface IMarketplacePublisherRepository extends IBaseMongoRepository<IMarketplacePublisherModel> {
+    findByPublisherName(publisherName: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    findPublishers(
+        search?: string,
+        orderBy?: string,
+        orderDirection?: 'ASC' | 'DESC',
+        limit?: number,
+        offset?: number,
+    ): Promise<{
+        publishers: AsDomainType<IMarketplacePublisherModel>[];
+        totalCount: number;
+    }>;
+    updatePublisherStats(
+        publisherId: string,
+        stats: {
+            extensionCount?: number;
+            totalInstalls?: number;
+            averageRating?: number;
+        },
+    ): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    verifyPublisher(publisherId: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+}

package/lib/templates/repositories/RegistryExtensionRepository.ts.template

@@ -1,4 +1,4 @@
-import { IPublishRequest, IExtensionRelease, IBaseMongoRepository, IRegistryExtensionModel, IExtensionReleaseModel, AsDomainType } from 'common/server';
+import { IMarketplacePublishExtensionInput, IExtensionRelease, IBaseMongoRepository, IRegistryExtensionModel, IExtensionReleaseModel, AsDomainType } from 'common/server';
 
 export interface IRegistryExtensionRepository extends IBaseMongoRepository<IRegistryExtensionModel> {
     extensionReleases(extensionSlug: string): Promise<AsDomainType<IExtensionReleaseModel>[]>;
@@ -11,7 +11,7 @@ export interface IRegistryExtensionRepository extends IBaseMongoRepository<IRegi
 
     deleteExtension(extensionSlug: string): boolean | Promise<boolean>;
 
-    publishExtension(request: IPublishRequest): Promise<AsDomainType<IRegistryExtensionModel>>;
+    publishExtension(request: IMarketplacePublishExtensionInput): Promise<AsDomainType<IRegistryExtensionModel>>;
 
     findExtensions(first: number, query: string, local?: boolean, remote?: boolean, prioritizeExtensionIDs?: string[]): Promise<AsDomainType<IRegistryExtensionModel>[]>;
 

package/lib/templates/services/ExtensionGalleryDataLoader.ts.template

@@ -0,0 +1,2 @@
+import { IGalleryExtension, IDataLoader } from 'common/server';
+export type IExtensionGalleryDataLoader = IDataLoader<IGalleryExtension>;

package/lib/templates/services/ExtensionGalleryService.ts.template

@@ -0,0 +1,79 @@
+// from package: marketplace-server
+import {
+    IGalleryExtension,
+    IExtensionIdentifier,
+    IExtensionManifest,
+    IGalleryPager,
+    AsDomainType,
+    IRegistryExtensionModel,
+} from 'common/server';
+
+/**
+ * Query options interface for gallery searches
+ */
+export interface IQueryOptions {
+    text?: string;
+    pageSize?: number;
+}
+
+/**
+ * Service interface for managing extension gallery
+ * IMPORTANT: All service methods that return domain entities MUST use AsDomainType<IEntityModel>
+ * This ensures proper type compatibility between MongoDB models and GraphQL domain types
+ */
+export interface IExtensionGalleryService {
+    /**
+     * Check if gallery service is enabled
+     */
+    isEnabled(): boolean;
+
+    /**
+     * Query extensions in gallery
+     */
+    query(options?: IQueryOptions): Promise<IGalleryPager>;
+
+    /**
+     * Get a specific extension by identifier
+     */
+    getExtension(identifier: IExtensionIdentifier | string): Promise<IGalleryExtension | null>;
+
+    /**
+     * Download an extension
+     */
+    download(extension: IGalleryExtension): Promise<string>;
+
+    /**
+     * Get extension README content
+     */
+    getReadme(extension: IGalleryExtension): Promise<string>;
+
+    /**
+     * Get extension manifest
+     */
+    getManifest(extension: IGalleryExtension): Promise<IExtensionManifest | null>;
+
+    /**
+     * Get extension changelog
+     */
+    getChangelog(extension: IGalleryExtension): Promise<string>;
+
+    /**
+     * Get extension license
+     */
+    getLicense(extension: IGalleryExtension): Promise<string>;
+
+    /**
+     * Load compatible version of extension
+     */
+    loadCompatibleVersion(extension: IGalleryExtension): Promise<IGalleryExtension>;
+}
+
+/**
+ * This file augments the ServerContext interface from the central apollo-context.
+ * Through declaration merging, the extensionGalleryService will be added to the ServerContext.
+ */
+declare module '../apollo-context' {
+    export interface ServerContext {
+        extensionGalleryService: IExtensionGalleryService;
+    }
+}

package/lib/templates/services/InstalledExtensionService.ts.template

@@ -11,8 +11,8 @@ import {
  * Input type for creating installed extensions with additional server-side fields
  */
 export interface ICreateInstalledExtensionInput extends IInstallExtensionInput {
-    extensionId: string;
-    tenantId: string;
+    extensionId: string; // ObjectId reference to extension registry
+    orgId: string; // Organization ID
     installedVersion: string;
     installedBy: string; // User ObjectId as string
 }
@@ -54,14 +54,13 @@ export interface IUpdateInstalledExtensionInput {
  * Filter input for querying installed extensions
  */
 export interface IInstalledExtensionFilter {
-    tenantId?: string;
-    extensionSlug?: string; // From GraphQL: extensionSlug field
-    extension?: string; // ObjectId as string reference
+    accountId?: string; // Account ID for filtering extensions by account
+    orgId?: string; // Organization ID for filtering extensions by organization  
+    extension?: string; // ObjectId as string reference to extension registry
     status?: string[];
-    registryStatus?: string[];
-    isOrphaned?: boolean;
-    userEnabled?: boolean;
-    systemEnabled?: boolean;
+    'lifecycle.registryStatus'?: string[];
+    'lifecycle.isOrphaned'?: boolean;
+    'settings.effectiveEnabled'?: boolean;
     installedBy?: string;
 }
 
@@ -73,60 +72,78 @@ export interface IInstalledExtensionService extends IBaseService<IInstalledExten
     /**
      * Install a new extension from the registry
      */
-    installExtension(input: ICreateInstalledExtensionInput): Promise<AsDomainType<IInstalledExtensionModel>>;
+    installExtension(input: ICreateInstalledExtensionInput, tenantId: string): Promise<AsDomainType<IInstalledExtensionModel>>;
 
     /**
-     * Uninstall an extension
+     * Uninstall an extension - now supports accountId and orgId based filtering
      */
-    uninstallExtension(tenantId: string, extensionSlug: string, uninstalledBy: string): Promise<boolean>;
+    uninstallExtension(
+        orgId: string,
+        extensionSlug: string,
+        uninstalledBy: string,
+        tenantId: string
+    ): Promise<boolean>;
 
     /**
-     * Update an installed extension's configuration or status
+     * Update an installed extension's configuration or status - now supports accountId and orgId based filtering
      */
     updateInstalledExtension(
-        tenantId: string,
+        orgId: string,
         extensionSlug: string,
         update: IUpdateInstalledExtensionInput,
+        tenantId: string,
     ): Promise<AsDomainType<IInstalledExtensionModel>>;
 
     /**
-     * Get a specific installed extension
+     * Get a specific installed extension - now supports accountId and orgId based filtering
      */
-    getInstalledExtension(tenantId: string, extensionSlug: string): Promise<AsDomainType<IInstalledExtensionModel> | null>;
+    getInstalledExtension(
+        orgId: string,
+        extensionSlug: string,
+    ): Promise<AsDomainType<IInstalledExtensionModel> | null>;
 
     /**
-     * Get all installed extensions for a tenant with optional filtering
+     * Get all installed extensions with optional filtering - now supports accountId and orgId based filtering
      */
     getInstalledExtensions(filter: IInstalledExtensionFilter): Promise<AsDomainType<IInstalledExtensionModel>[]>;
 
     /**
-     * Enable/disable an installed extension
+     * Get all installed extensions for a specific extension by extensionSlug
+     * Useful for finding all organizations that have installed a specific extension
+     */
+    getInstalledExtensionsBySlug(extensionSlug: string): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+
+    /**
+     * Enable/disable an installed extension - now supports accountId and orgId based filtering
      */
     toggleExtension(
-        tenantId: string,
+        orgId: string,
         extensionSlug: string,
         enabled: boolean,
         toggledBy: string,
+        tenantId: string,
     ): Promise<AsDomainType<IInstalledExtensionModel>>;
 
     /**
-     * Update extension settings/configuration
+     * Update extension settings/configuration - now supports accountId and orgId based filtering
      */
     updateExtensionSettings(
-        tenantId: string,
+        orgId: string,
         extensionSlug: string,
         userConfig: Record<string, unknown>,
         updatedBy: string,
+        tenantId: string,
     ): Promise<AsDomainType<IInstalledExtensionModel>>;
 
     /**
-     * Check for extension updates and return available updates
+     * Check for extension updates and return available updates - now supports accountId and orgId based filtering
      */
     checkForUpdates(
-        tenantId: string,
+        orgId: string,
         extensionSlug?: string,
     ): Promise<
         Array<{
+            extensionId: string;
             extensionSlug: string;
             currentVersion: string;
             availableVersion: string;
@@ -135,34 +152,48 @@ export interface IInstalledExtensionService extends IBaseService<IInstalledExten
     >;
 
     /**
-     * Update an extension to a newer version
+     * Update an extension to a newer version - now supports accountId and orgId based filtering
      */
     updateExtensionVersion(
-        tenantId: string,
+        orgId: string,
         extensionSlug: string,
         targetVersion: string,
         updatedBy: string,
+        tenantId: string
     ): Promise<AsDomainType<IInstalledExtensionModel>>;
 
     /**
-     * Sync installed extensions with registry status (for orphaned, deprecated, etc.)
+     * Sync installed extensions with registry status (for orphaned, deprecated, etc.) - now supports accountId and orgId based filtering
      */
-    syncWithRegistry(tenantId: string): Promise<void>;
+    syncWithRegistry(orgId: string, tenantId: string): Promise<void>;
 
     /**
-     * Get extensions that need attention (deprecated, orphaned, security updates, etc.)
+     * Get extensions that need attention (deprecated, orphaned, security updates, etc.) - now supports accountId and orgId based filtering
      */
-    getExtensionsNeedingAttention(tenantId: string): Promise<AsDomainType<IInstalledExtensionModel>[]>;
+    getExtensionsNeedingAttention(orgId: string): Promise<AsDomainType<IInstalledExtensionModel>[]>;
 
     /**
-     * Clean up deprecated or removed extensions based on policies
+     * Clean up deprecated or removed extensions based on policies - now supports accountId and orgId based filtering
      */
     cleanupExtensions(
+        orgId: string,
+        tenantId: string,
+        dryRun?: boolean,
+    ): Promise<{
+        removed: string[]; // Array of extension ObjectIds
+        deprecated: string[]; // Array of extension ObjectIds
+        warnings: string[];
+    }>;
+
+    /**
+     * Clean up orphaned extensions that exist in installed_extensions but not in system_extension registry
+     */
+    cleanupOrphanedExtensions(
+        orgId: string,
         tenantId: string,
         dryRun?: boolean,
     ): Promise<{
-        removed: string[];
-        deprecated: string[];
+        removed: string[]; // Array of extension slugs
         warnings: string[];
     }>;
 }

package/lib/templates/services/MarketplacePublisherService.ts.template

@@ -0,0 +1,51 @@
+import { IBaseService, IMarketplacePublisherModel, AsDomainType } from 'common/server';
+
+export interface IMarketplacePublisherService extends IBaseService<IMarketplacePublisherModel> {
+    findById(id: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    findByPublisherName(publisherName: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    findPublishers(
+        search?: string,
+        orderBy?: string,
+        orderDirection?: 'ASC' | 'DESC',
+        first?: number,
+        after?: number,
+    ): Promise<{
+        publishers: AsDomainType<IMarketplacePublisherModel>[];
+        totalCount: number;
+    }>;
+    createPublisher(data: {
+        displayName: string;
+        publisherName: string;
+        description?: string;
+        website?: string;
+        domain?: string;
+        tenant?: string;
+    }): Promise<AsDomainType<IMarketplacePublisherModel>>;
+    updatePublisher(
+        publisherId: string,
+        data: {
+            displayName?: string;
+            description?: string;
+            website?: string;
+            avatarUrl?: string;
+            tenant?: string;
+        },
+    ): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    updatePublisherStats(
+        publisherId: string,
+        stats: {
+            extensionCount?: number;
+            totalInstalls?: number;
+            averageRating?: number;
+        },
+    ): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    verifyPublisher(publisherId: string): Promise<AsDomainType<IMarketplacePublisherModel> | null>;
+    getPublisherStats(publisherId: string): Promise<{
+        totalExtensions: number;
+        totalDownloads: number;
+        totalInstallations: number;
+        averageRating: number;
+        verifiedCount: number;
+        topExtension?: unknown; // TODO: Should be IRegistryExtension when available
+    } | null>;
+}

package/lib/templates/services/PublisherDataLoader.ts.template

@@ -0,0 +1,3 @@
+import { IMarketplacePublisherModel, IDataLoader } from 'common/server';
+
+export type IPublisherDataLoader = IDataLoader<IMarketplacePublisherModel>;

package/lib/templates/services/PublisherEventService.ts.template

@@ -0,0 +1,56 @@
+// from package: marketplace-server
+
+/**
+ * Service interface for managing publisher analytics events
+ */
+export interface IPublisherEventService {
+    recordEvent(event: {
+        publisherId: string;
+        extensionId?: string;
+        eventType: 'download' | 'install' | 'view' | 'rating';
+        value?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+
+    getPublisherStats(publisherId: string): Promise<{
+        totalDownloads: number;
+        totalInstalls: number;
+        totalViews: number;
+        totalRatings: number;
+        averageRating: number;
+        extensionCount: number;
+        lastUpdated: Date;
+    }>;
+
+    getPublisherAnalytics(
+        publisherId: string,
+        startDate: Date,
+        endDate: Date,
+        granularity: string,
+    ): Promise<
+        Array<{
+            date: Date;
+            downloads: number;
+            installs: number;
+            views: number;
+            ratings: number;
+            averageRating: number;
+            uniqueUsers: number;
+        }>
+    >;
+
+    getPublisherTrends(
+        publisherId: string,
+        days: number,
+    ): Promise<{
+        downloadTrend: string;
+        downloadChange: number;
+        installTrend: string;
+        installChange: number;
+        viewTrend: string;
+        viewChange: number;
+        ratingTrend: string;
+        ratingChange: number;
+        trendScore: number;
+    }>;
+}

package/lib/templates/services/RegistryExtensionService.ts.template

@@ -1,4 +1,4 @@
-import { IPublishRequest, IExtensionRelease, IBaseService, IRegistryExtensionModel, AsDomainType } from 'common/server';
+import { IMarketplacePublishExtensionInput, IExtensionRelease, IBaseService, IRegistryExtensionModel, AsDomainType } from 'common/server';
 
 export interface IRegistryExtensionService extends IBaseService<AsDomainType<IRegistryExtensionModel>> {
     extensionReleases(extensionSlug: string): Promise<IExtensionRelease[]>;
@@ -11,9 +11,53 @@ export interface IRegistryExtensionService extends IBaseService<AsDomainType<IRe
 
     deleteExtension(extensionSlug: string): boolean | Promise<boolean>;
 
-    publishExtension(request: IPublishRequest): Promise<AsDomainType<IRegistryExtensionModel>>;
+    publishExtension(request: IMarketplacePublishExtensionInput): Promise<AsDomainType<IRegistryExtensionModel>>;
 
     findExtensions(first: number, query: string, local?: boolean, remote?: boolean, prioritizeExtensionIDs?: string[]): Promise<AsDomainType<IRegistryExtensionModel>[]>;
 
     findExtension(extensionSlug: string): Promise<AsDomainType<IRegistryExtensionModel>>;
+
+    // Enhanced marketplace features
+    formSubmission(input: {
+        extensionSlug: string;
+        formData: string;
+        submissionType: string;
+        metadata?: string;
+    }): Promise<{
+        success: boolean;
+        message?: string;
+        errors?: string[];
+        submissionId?: string;
+        data?: string;
+    }>;
+
+    validateExtension(input: {
+        manifest: string;
+        bundle?: string;
+        sourceMap?: string;
+        extensionSlug?: string;
+        version?: string;
+    }): Promise<{
+        isValid: boolean;
+        errors: Array<{ field: string; message: string; code?: string }>;
+        warnings: Array<{ field: string; message: string; code?: string }>;
+        metadata?: string;
+    }>;
+
+    publishExtensionEnhanced(input: {
+        extensionSlug: string;
+        manifest: string;
+        bundle: string;
+        sourceMap?: string;
+        version: string;
+        releaseNotes?: string;
+        force?: boolean;
+        preRelease?: boolean;
+    }): Promise<{
+        success: boolean;
+        extension?: AsDomainType<IRegistryExtensionModel>;
+        message?: string;
+        errors?: string[];
+        releaseId?: string;
+    }>;
 }

package/lib/tests/extension-integration.test.d.ts

@@ -1,2 +1 @@
-export {};
 //# sourceMappingURL=extension-integration.test.d.ts.map

package/lib/tests/install-extension-graphql.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=install-extension-graphql.test.d.ts.map

package/lib/tests/install-extension-graphql.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-extension-graphql.test.d.ts","sourceRoot":"","sources":["../../src/tests/install-extension-graphql.test.ts"],"names":[],"mappings":""}

package/lib/utils/publisherValidation.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Backend validation utilities for publisher data
+ */
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+}
+/**
+ * Validates a publisher name on the backend
+ * Ensures it doesn't contain characters that would break URL routing or extension slug parsing
+ */
+export declare function validatePublisherName(publisherName: string): ValidationResult;
+/**
+ * Validates publisher data for creation or update
+ */
+export declare function validatePublisherData(data: {
+    publisherName: string;
+    displayName: string;
+    email?: string;
+    website?: string;
+    description?: string;
+}): ValidationResult;
+//# sourceMappingURL=publisherValidation.d.ts.map

package/lib/utils/publisherValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisherValidation.d.ts","sourceRoot":"","sources":["../../src/utils/publisherValidation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,gBAAgB;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,MAAM,GAAG,gBAAgB,CA4E7E;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,gBAAgB,CA2CnB"}

package/lib/utils/publisherValidation.js

@@ -0,0 +1,144 @@
+/**
+ * Backend validation utilities for publisher data
+ */
+/**
+ * Validates a publisher name on the backend
+ * Ensures it doesn't contain characters that would break URL routing or extension slug parsing
+ */
+function validatePublisherName(publisherName) {
+  if (!publisherName || publisherName.trim().length === 0) {
+    return {
+      valid: false,
+      error: 'Publisher name is required'
+    };
+  }
+  const trimmed = publisherName.trim();
+  // Check minimum length
+  if (trimmed.length < 2) {
+    return {
+      valid: false,
+      error: 'Publisher name must be at least 2 characters long'
+    };
+  }
+  // Check maximum length
+  if (trimmed.length > 50) {
+    return {
+      valid: false,
+      error: 'Publisher name must be less than 50 characters'
+    };
+  }
+  // Check for invalid characters that would break routing or parsing
+  if (trimmed.includes('/')) {
+    return {
+      valid: false,
+      error: 'Publisher name cannot contain forward slashes (/)'
+    };
+  }
+  if (trimmed.includes('.')) {
+    return {
+      valid: false,
+      error: 'Publisher name cannot contain dots (.)'
+    };
+  }
+  if (trimmed.includes('\\')) {
+    return {
+      valid: false,
+      error: 'Publisher name cannot contain backslashes (\\)'
+    };
+  }
+  // Check for other URL-unsafe characters
+  const urlUnsafeChars = ['?', '#', '&', '%', '+', '=', '<', '>', '"', '`', '{', '}', '|', '^', '[', ']', '@', ':', ';', ',', ' '];
+  for (const char of urlUnsafeChars) {
+    if (trimmed.includes(char)) {
+      return {
+        valid: false,
+        error: `Publisher name cannot contain the character: ${char}`
+      };
+    }
+  }
+  // Check if it starts or ends with special characters
+  if (trimmed.startsWith('-') || trimmed.endsWith('-')) {
+    return {
+      valid: false,
+      error: 'Publisher name cannot start or end with hyphens'
+    };
+  }
+  if (trimmed.startsWith('_') || trimmed.endsWith('_')) {
+    return {
+      valid: false,
+      error: 'Publisher name cannot start or end with underscores'
+    };
+  }
+  // Only allow alphanumeric characters, hyphens, and underscores
+  const validPattern = /^[a-zA-Z0-9]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
+  if (!validPattern.test(trimmed)) {
+    return {
+      valid: false,
+      error: 'Publisher name can only contain letters, numbers, hyphens, and underscores'
+    };
+  }
+  return {
+    valid: true
+  };
+}
+/**
+ * Validates publisher data for creation or update
+ */
+function validatePublisherData(data) {
+  // Validate publisher name
+  const nameValidation = validatePublisherName(data.publisherName);
+  if (!nameValidation.valid) {
+    return nameValidation;
+  }
+  // Validate display name
+  if (!data.displayName || data.displayName.trim().length === 0) {
+    return {
+      valid: false,
+      error: 'Display name is required'
+    };
+  }
+  if (data.displayName.trim().length > 100) {
+    return {
+      valid: false,
+      error: 'Display name must be less than 100 characters'
+    };
+  }
+  // Validate email if provided
+  if (data.email && data.email.trim().length > 0) {
+    const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailPattern.test(data.email)) {
+      return {
+        valid: false,
+        error: 'Please provide a valid email address'
+      };
+    }
+  }
+  // Validate website if provided
+  if (data.website && data.website.trim().length > 0) {
+    try {
+      const url = new URL(data.website);
+      // URL constructor validates the URL format
+      if (!url.protocol.startsWith('http')) {
+        return {
+          valid: false,
+          error: 'Website must use http or https protocol'
+        };
+      }
+    } catch {
+      return {
+        valid: false,
+        error: 'Website must be a valid URL'
+      };
+    }
+  }
+  // Validate description length if provided
+  if (data.description && data.description.length > 1000) {
+    return {
+      valid: false,
+      error: 'Description must be less than 1000 characters'
+    };
+  }
+  return {
+    valid: true
+  };
+}export{validatePublisherData,validatePublisherName};//# sourceMappingURL=publisherValidation.js.map

package/lib/utils/publisherValidation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisherValidation.js","sources":["../../src/utils/publisherValidation.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;AAEG;AAEH;;;AAGC;AAED,SAAA,qBAAA,CAAA,aAAA,EAAA;;;AAGG,MAAA,KAAA,EAAA,KAAA;AACH,MAAA,KAAA,EAAA;AA8EA,KAAA;;AAEG,EAAA,MAAA,OAAA,GAAA,aAAA,CAAA,IAAA,EAAA;AACH;MACI,OAAA,CAAA,YAAsB;IACtB,OAAA;MACA,KAAM,EAAE,KAAM;MACd,KAAO,EAAC;KACR;AACH,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}