@simpleapps-com/augur-api 0.3.2 → 0.4.0

package/dist/types/services/brand-folder/client.d.ts

@@ -3,186 +3,216 @@ import type { HTTPClient } from '../../core/client';
 import { CategoryFocusRequestParams, CategoryFocusResult } from './schemas';
 /**
  * Brand Folder Service Client
- *
- * Provides access to brand folder management endpoints for category focus
- * management and brand organization capabilities.
- *
+ * @description Client for interacting with Brand Folder API endpoints for category focus management and brand organization
+ * @fullPath api.brandFolder
  * @service brand-folder
  * @domain brand-management
+ * @discoverable true
+ * @searchTerms ["brand-folder", "category focus", "brand management", "category organization", "brand configuration", "focus management"]
+ * @relatedEndpoints ["api.brandFolder.healthCheck.get", "api.brandFolder.categories.focus.create", "api.items.categories.list", "api.commerce.brands.list"]
+ * @commonPatterns ["Brand management", "Category focus configuration", "Brand organization", "Category prioritization"]
+ * @workflow ["brand-management", "category-organization", "content-management", "merchandising"]
+ * @functionalArea "brand-and-category-management"
+ * @businessRules ["Requires valid bearer authentication", "Category focus configuration", "Brand-category associations", "Priority-based organization"]
+ * @performance "Optimized for brand management workflows and category focus operations"
+ * @example
+ * ```typescript
+ * import { HTTPClient } from '@augur/api-client/core';
+ * import { BrandFolderClient } from '@augur/api-client/services/brand-folder';
+ *
+ * const http = new HTTPClient('brand-folder', { siteId: 'your-site-id', bearerToken: 'your-token' });
+ * const brandFolder = new BrandFolderClient(http);
+ *
+ * // Check service health
+ * const health = await brandFolder.healthCheck.get();
+ * const healthData = await brandFolder.healthCheck.getData();
+ *
+ * // Set category focus
+ * const focusConfig = {
+ *   categoryId: 'cat-123',
+ *   focusLevel: 'primary' as const,
+ *   priority: 95,
+ *   isActive: true
+ * };
+ * const focus = await brandFolder.categories.focus.create(focusConfig);
+ * const focusData = await brandFolder.categories.focus.getData(focusConfig);
+ * ```
  */
 export declare class BrandFolderClient extends BaseServiceClient {
     constructor(http: HTTPClient, baseUrl?: string);
     protected getServiceDescription(): string;
     /**
-     * Check service health and availability
-     *
-     * @fullPath api.brandFolder.healthCheck.get
-     * @service brand-folder
-     * @domain system-health
-     * @dataMethod healthCheckData
-     * @discoverable true
-     * @searchTerms ["health", "status", "availability", "ping", "check", "brand service"]
-     * @relatedEndpoints ["api.brandFolder.categories.focus.set", "api.avalara.healthCheck.get", "api.agrWork.healthCheck.get", "api.agrInfo.healthCheck.get"]
-     * @commonPatterns ["Health check", "Service status", "Brand service availability", "System monitoring"]
-     * @workflow ["system-monitoring", "health-checks", "service-discovery", "brand-service-verification"]
-     * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header"]
-     * @nextSteps ["Use brand management endpoints if healthy", "Verify brand service connectivity", "Monitor service metrics"]
-     * @businessRules ["Returns service status and basic info", "Requires standard authentication", "Standard health check format"]
-     * @functionalArea "system-monitoring"
-     * @caching "No caching - real-time status required"
-     * @performance "Fast response, minimal processing, use for brand service monitoring"
-     *
-     * @returns Promise<HealthCheckResponse> Service health status
-     *
-     * @example
-     * ```typescript
-     * // Check if brand service is healthy
-     * const response = await client.healthCheck();
-     * console.log(response.data); // Health status string
-     * console.log(response.status); // HTTP status code
-     *
-     * // Get just the health status
-     * const status = await client.healthCheckData();
-     * console.log(status); // Direct string access
-     * ```
+     * Health Check Operations
+     * @description System health monitoring and availability verification for Brand Folder service
      */
-    readonly healthCheck: () => Promise<{
-        params: Record<string, unknown> | unknown[];
-        data: string;
-        options: Record<string, unknown> | unknown[];
-        status: number;
-        message: string;
-        count: number;
-        total: number;
-        totalResults: number;
-    }>;
+    healthCheck: {
+        /**
+         * Check service health and availability
+         *
+         * @fullPath api.brandFolder.healthCheck.get
+         * @service brand-folder
+         * @domain system-health
+         * @dataMethod healthCheck.getData - returns only the health status data without metadata
+         * @discoverable true
+         * @searchTerms ["health", "status", "availability", "ping", "check", "brand service", "monitoring"]
+         * @relatedEndpoints ["api.brandFolder.categories.focus.create", "api.avalara.healthCheck.get", "api.agrWork.healthCheck.get", "api.agrInfo.healthCheck.get", "api.items.healthCheck.get"]
+         * @commonPatterns ["Health check", "Service status", "Brand service availability", "System monitoring"]
+         * @workflow ["system-monitoring", "health-checks", "service-discovery", "brand-service-verification"]
+         * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header"]
+         * @nextSteps ["Use brand management endpoints if healthy", "Verify brand service connectivity", "Monitor service metrics"]
+         * @businessRules ["Returns service status and basic info", "Requires standard authentication", "Standard health check format"]
+         * @functionalArea "system-monitoring"
+         * @caching "No caching - real-time status required"
+         * @performance "Fast response, minimal processing, use for brand service monitoring"
+         *
+         * @returns Promise<HealthCheckResponse> Service health status
+         *
+         * @example
+         * ```typescript
+         * // Check if brand service is healthy
+         * const response = await client.healthCheck.get();
+         * console.log(response.data); // Health status string
+         * console.log(response.status); // HTTP status code
+         *
+         * // Get just the health status
+         * const status = await client.healthCheck.getData();
+         * console.log(status); // Direct string access
+         * ```
+         */
+        get: () => Promise<{
+            params: Record<string, unknown> | unknown[];
+            data: string;
+            options: Record<string, unknown> | unknown[];
+            status: number;
+            message: string;
+            count: number;
+            total: number;
+            totalResults: number;
+        }>;
+        /**
+         * Get health check status data only
+         * @returns Promise<string> Health status string
+         */
+        getData: () => Promise<string>;
+    };
     /**
-     * Set category focus configuration for brand management
-     *
-     * @fullPath api.brandFolder.categories.focus.set
-     * @service brand-folder
-     * @domain brand-management
-     * @dataMethod categoriesFocusSetData
-     * @discoverable true
-     * @searchTerms ["category", "focus", "brand", "priority", "configuration", "management", "organization"]
-     * @relatedEndpoints ["api.items.categories.list", "api.commerce.brands.list", "api.customers.preferences.set", "api.items.catalog.organize"]
-     * @commonPatterns ["Set category focus", "Configure brand priorities", "Organize brand categories", "Manage category visibility", "Brand taxonomy management"]
-     * @workflow ["brand-management", "category-organization", "content-management", "merchandising", "brand-strategy"]
-     * @prerequisites ["Valid brand/category data", "Public bearer token", "x-site-id header", "Category or brand identification"]
-     * @nextSteps ["Verify focus configuration", "Update brand displays", "Refresh category hierarchies", "Monitor brand performance"]
-     * @businessRules ["Supports primary/secondary/tertiary focus levels", "Allows priority ranking 1-100", "Configurable visibility settings", "Brand-category associations", "Effective date management"]
-     * @functionalArea "brand-and-category-management"
-     * @crossSite "Multi-site brand focus configuration support"
-     * @caching "Cache for 30 minutes, brand focus changes infrequently"
-     * @performance "Optimize by batching multiple category updates, validate before submission"
-     *
-     * @param params Category focus configuration parameters including focus level, priority, and brand associations
-     * @returns Promise<CategoryFocusResponse> Complete category focus configuration results with applied settings
-     *
-     * @example
-     * ```typescript
-     * // Set primary focus for a category
-     * const focusConfig = {
-     *   categoryId: 'cat-123',
-     *   focusLevel: 'primary' as const,
-     *   priority: 95,
-     *   isActive: true,
-     *   brandId: 'brand-456',
-     *   visibility: 'public' as const,
-     *   featured: true
-     * };
-     *
-     * const response = await client.categoriesFocusSet(focusConfig);
-     * console.log(response.data.focusLevel); // Applied focus level
-     * console.log(response.data.priority); // Set priority value
-     *
-     * // Get just the focus result
-     * const focusResult = await client.categoriesFocusSetData(focusConfig);
-     * console.log(focusResult.categoryId); // Direct access to category ID
-     *
-     * // Configure category with brand association
-     * const brandFocusConfig = {
-     *   categoryName: 'Electronics',
-     *   categorySlug: 'electronics',
-     *   focusLevel: 'secondary' as const,
-     *   priority: 75,
-     *   brandName: 'TechBrand',
-     *   description: 'Featured electronics category',
-     *   tags: ['electronics', 'featured', 'tech'],
-     *   displayOrder: 2,
-     *   visibility: 'public' as const
-     * };
-     *
-     * const brandResult = await client.categoriesFocusSetData(brandFocusConfig);
-     *
-     * // Batch category focus updates
-     * const categories = [
-     *   { categoryId: 'cat-1', focusLevel: 'primary' as const, priority: 100 },
-     *   { categoryId: 'cat-2', focusLevel: 'secondary' as const, priority: 80 },
-     *   { categoryId: 'cat-3', focusLevel: 'tertiary' as const, priority: 60 }
-     * ];
-     *
-     * // Process multiple categories
-     * for (const category of categories) {
-     *   const result = await client.categoriesFocusSetData(category);
-     *   console.log(`Set ${category.categoryId} to ${result.focusLevel}`);
-     * }
-     * ```
+     * Categories Operations
+     * @description Category management and organization functionality
      */
-    readonly categoriesFocusSet: (data: import("zod").objectInputType<{
-        categoryId: import("zod").ZodOptional<import("zod").ZodString>;
-        categoryName: import("zod").ZodOptional<import("zod").ZodString>;
-        categorySlug: import("zod").ZodOptional<import("zod").ZodString>;
-        focusLevel: import("zod").ZodOptional<import("zod").ZodEnum<["primary", "secondary", "tertiary"]>>;
-        priority: import("zod").ZodOptional<import("zod").ZodNumber>;
-        isActive: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        brandId: import("zod").ZodOptional<import("zod").ZodString>;
-        brandName: import("zod").ZodOptional<import("zod").ZodString>;
-        description: import("zod").ZodOptional<import("zod").ZodString>;
-        tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
-        startDate: import("zod").ZodOptional<import("zod").ZodString>;
-        endDate: import("zod").ZodOptional<import("zod").ZodString>;
-        displayOrder: import("zod").ZodOptional<import("zod").ZodNumber>;
-        visibility: import("zod").ZodOptional<import("zod").ZodEnum<["public", "private", "draft"]>>;
-        featured: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    }, import("zod").ZodTypeAny, "passthrough">) => Promise<{
-        params: Record<string, unknown> | unknown[];
-        data: {
-            expirationDate?: string | undefined;
-            brandName?: string | undefined;
-            brandId?: string | undefined;
-            priority?: number | undefined;
-            isActive?: boolean | undefined;
-            displayOrder?: number | undefined;
-            categoryId?: string | undefined;
-            categoryName?: string | undefined;
-            categorySlug?: string | undefined;
-            focusLevel?: string | undefined;
-            visibility?: string | undefined;
-            featured?: boolean | undefined;
-            createdAt?: string | undefined;
-            updatedAt?: string | undefined;
-            effectiveDate?: string | undefined;
-        } & {
-            [k: string]: unknown;
+    categories: {
+        /**
+         * Focus Operations
+         * @description Category focus configuration and priority management
+         */
+        focus: {
+            /**
+             * Set category focus configuration for brand management
+             *
+             * @fullPath api.brandFolder.categories.focus.create
+             * @service brand-folder
+             * @domain brand-management
+             * @dataMethod categories.focus.getData - returns only the focus configuration data without metadata
+             * @discoverable true
+             * @searchTerms ["category", "focus", "brand", "priority", "configuration", "management", "organization", "create"]
+             * @relatedEndpoints ["api.items.categories.list", "api.commerce.brands.list", "api.customers.preferences.set", "api.items.catalog.organize"]
+             * @commonPatterns ["Set category focus", "Configure brand priorities", "Organize brand categories", "Manage category visibility", "Brand taxonomy management"]
+             * @workflow ["brand-management", "category-organization", "content-management", "merchandising", "brand-strategy"]
+             * @prerequisites ["Valid brand/category data", "Public bearer token", "x-site-id header", "Category or brand identification"]
+             * @nextSteps ["Verify focus configuration", "Update brand displays", "Refresh category hierarchies", "Monitor brand performance"]
+             * @businessRules ["Supports primary/secondary/tertiary focus levels", "Allows priority ranking 1-100", "Configurable visibility settings", "Brand-category associations", "Effective date management"]
+             * @functionalArea "brand-and-category-management"
+             * @crossSite "Multi-site brand focus configuration support"
+             * @caching "Cache for 30 minutes, brand focus changes infrequently"
+             * @performance "Optimize by batching multiple category updates, validate before submission"
+             *
+             * @param params Category focus configuration parameters including focus level, priority, and brand associations
+             * @returns Promise<CategoryFocusResponse> Complete category focus configuration results with applied settings
+             *
+             * @example
+             * ```typescript
+             * // Set primary focus for a category
+             * const focusConfig = {
+             *   categoryId: 'cat-123',
+             *   focusLevel: 'primary' as const,
+             *   priority: 95,
+             *   isActive: true,
+             *   brandId: 'brand-456',
+             *   visibility: 'public' as const,
+             *   featured: true
+             * };
+             *
+             * const response = await client.categories.focus.create(focusConfig);
+             * console.log(response.data.focusLevel); // Applied focus level
+             * console.log(response.data.priority); // Set priority value
+             *
+             * // Get just the focus result
+             * const focusResult = await client.categories.focus.getData(focusConfig);
+             * console.log(focusResult.categoryId); // Direct access to category ID
+             *
+             * // Configure category with brand association
+             * const brandFocusConfig = {
+             *   categoryName: 'Electronics',
+             *   categorySlug: 'electronics',
+             *   focusLevel: 'secondary' as const,
+             *   priority: 75,
+             *   brandName: 'TechBrand',
+             *   description: 'Featured electronics category',
+             *   tags: ['electronics', 'featured', 'tech'],
+             *   displayOrder: 2,
+             *   visibility: 'public' as const
+             * };
+             *
+             * const brandResult = await client.categories.focus.getData(brandFocusConfig);
+             *
+             * // Batch category focus updates
+             * const categories = [
+             *   { categoryId: 'cat-1', focusLevel: 'primary' as const, priority: 100 },
+             *   { categoryId: 'cat-2', focusLevel: 'secondary' as const, priority: 80 },
+             *   { categoryId: 'cat-3', focusLevel: 'tertiary' as const, priority: 60 }
+             * ];
+             *
+             * // Process multiple categories
+             * for (const category of categories) {
+             *   const result = await client.categories.focus.getData(category);
+             *   console.log(`Set ${category.categoryId} to ${result.focusLevel}`);
+             * }
+             * ```
+             */
+            create: (params: CategoryFocusRequestParams) => Promise<{
+                params: Record<string, unknown> | unknown[];
+                data: {
+                    expirationDate?: string | undefined;
+                    brandName?: string | undefined;
+                    brandId?: string | undefined;
+                    priority?: number | undefined;
+                    isActive?: boolean | undefined;
+                    displayOrder?: number | undefined;
+                    createdAt?: string | undefined;
+                    updatedAt?: string | undefined;
+                    categoryId?: string | undefined;
+                    categoryName?: string | undefined;
+                    categorySlug?: string | undefined;
+                    focusLevel?: string | undefined;
+                    visibility?: string | undefined;
+                    featured?: boolean | undefined;
+                    effectiveDate?: string | undefined;
+                } & {
+                    [k: string]: unknown;
+                };
+                options: Record<string, unknown> | unknown[];
+                status: number;
+                message: string;
+                count: number;
+                total: number;
+                totalResults: number;
+            }>;
+            /**
+             * Set category focus configuration and return result data only
+             * @param params Category focus configuration parameters
+             * @returns Promise<CategoryFocusResult> Category focus configuration result with applied settings
+             */
+            getData: (params: CategoryFocusRequestParams) => Promise<CategoryFocusResult>;
         };
-        options: Record<string, unknown> | unknown[];
-        status: number;
-        message: string;
-        count: number;
-        total: number;
-        totalResults: number;
-    }>;
-    /**
-     * Get health check status data only
-     * @returns Promise<string> Health status string
-     */
-    readonly healthCheckData: () => Promise<string>;
-    /**
-     * Set category focus configuration and return result data only
-     * @param params Category focus configuration parameters
-     * @returns Promise<CategoryFocusResult> Category focus configuration result with applied settings
-     */
-    readonly categoriesFocusSetData: (params: CategoryFocusRequestParams) => Promise<CategoryFocusResult>;
+    };
 }
 //# sourceMappingURL=client.d.ts.map

package/dist/types/services/brand-folder/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/services/brand-folder/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAGL,0BAA0B,EAE1B,mBAAmB,EACpB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;GAQG;AACH,qBAAa,iBAAkB,SAAQ,iBAAiB;gBAC1C,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,MAAM;IAI9C,SAAS,CAAC,qBAAqB,IAAI,MAAM;IAIzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,QAAQ,CAAC,WAAW;;;;;;;;;OAA2D;IAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwEG;IACH,QAAQ,CAAC,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAIzB;IAIF;;;OAGG;IACH,QAAQ,CAAC,eAAe,QAAa,OAAO,CAAC,MAAM,CAAC,CAGlD;IAEF;;;;OAIG;IACH,QAAQ,CAAC,sBAAsB,GAC7B,QAAQ,0BAA0B,KACjC,OAAO,CAAC,mBAAmB,CAAC,CAG7B;CACH"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/services/brand-folder/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAEL,0BAA0B,EAE1B,mBAAmB,EACpB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,iBAAkB,SAAQ,iBAAiB;gBAC1C,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,MAAM;IAI9C,SAAS,CAAC,qBAAqB,IAAI,MAAM;IAIzC;;;OAGG;IACH,WAAW;QACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCG;;;;;;;;;;;QAYH;;;WAGG;uBACgB,OAAO,CAAC,MAAM,CAAC;MAIlC;IAEF;;;OAGG;IACH,UAAU;QACR;;;WAGG;;YAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAwEG;6BACoB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAWjD;;;;eAIG;8BACqB,0BAA0B,KAAG,OAAO,CAAC,mBAAmB,CAAC;;MAKnF;CACH"}

package/dist/types/services/brand-folder/schemas.d.ts

@@ -212,14 +212,14 @@ export declare const CategoryFocusResponseSchema: z.ZodEffects<z.ZodObject<{
         priority?: number | undefined;
         isActive?: boolean | undefined;
         displayOrder?: number | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
         categoryId?: string | undefined;
         categoryName?: string | undefined;
         categorySlug?: string | undefined;
         focusLevel?: string | undefined;
         visibility?: string | undefined;
         featured?: boolean | undefined;
-        createdAt?: string | undefined;
-        updatedAt?: string | undefined;
         effectiveDate?: string | undefined;
     } & {
         [k: string]: unknown;
@@ -239,14 +239,14 @@ export declare const CategoryFocusResponseSchema: z.ZodEffects<z.ZodObject<{
         priority?: number | undefined;
         isActive?: boolean | undefined;
         displayOrder?: number | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
         categoryId?: string | undefined;
         categoryName?: string | undefined;
         categorySlug?: string | undefined;
         focusLevel?: string | undefined;
         visibility?: string | undefined;
         featured?: boolean | undefined;
-        createdAt?: string | undefined;
-        updatedAt?: string | undefined;
         effectiveDate?: string | undefined;
     } & {
         [k: string]: unknown;
@@ -266,14 +266,14 @@ export declare const CategoryFocusResponseSchema: z.ZodEffects<z.ZodObject<{
         priority?: number | undefined;
         isActive?: boolean | undefined;
         displayOrder?: number | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
         categoryId?: string | undefined;
         categoryName?: string | undefined;
         categorySlug?: string | undefined;
         focusLevel?: string | undefined;
         visibility?: string | undefined;
         featured?: boolean | undefined;
-        createdAt?: string | undefined;
-        updatedAt?: string | undefined;
         effectiveDate?: string | undefined;
     } & {
         [k: string]: unknown;
@@ -293,14 +293,14 @@ export declare const CategoryFocusResponseSchema: z.ZodEffects<z.ZodObject<{
         priority?: number | undefined;
         isActive?: boolean | undefined;
         displayOrder?: number | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
         categoryId?: string | undefined;
         categoryName?: string | undefined;
         categorySlug?: string | undefined;
         focusLevel?: string | undefined;
         visibility?: string | undefined;
         featured?: boolean | undefined;
-        createdAt?: string | undefined;
-        updatedAt?: string | undefined;
         effectiveDate?: string | undefined;
     } & {
         [k: string]: unknown;