attio-mcp 0.1.0

package/dist/utils/filters/index.js

@@ -0,0 +1,67 @@
+/**
+ * Central export point for all filter-related functionality
+ * Maintains backward compatibility while providing organized module structure
+ */
+// Export all types
+export * from './types.js';
+// Export all validators
+export * from './validators.js';
+// Export all builders
+export * from './builders.js';
+// Export all translators
+export * from './translators.js';
+// Export all operators
+export * from './operators.js';
+// Export all utilities
+export * from './utils.js';
+// Export cache utilities
+export * from './cache.js';
+// Export relationship utilities
+export * from './relationship.js';
+// Re-export namespaced Basic utilities for backward compatibility
+import { transformFiltersToApiFormat } from './translators.js';
+import { validateFilterStructure } from './validators.js';
+import { createEqualsFilter, createContainsFilter, combineWithAnd, combineWithOr, } from './builders.js';
+export const Basic = {
+    validateFilterStructure,
+    transformFiltersToApiFormat,
+    createEqualsFilter,
+    createContainsFilter,
+    combineWithAnd,
+    combineWithOr,
+};
+// Re-export namespaced Range utilities for backward compatibility
+import { createDateRangeFilter, createCreatedDateFilter, createModifiedDateFilter, createNumericFilter, createRevenueFilter, createEmployeeCountFilter, } from './builders.js';
+export const Range = {
+    createDateRangeFilter,
+    createCreatedDateFilter,
+    createModifiedDateFilter,
+    createNumericFilter,
+    createRevenueFilter,
+    createEmployeeCountFilter,
+};
+// Re-export namespaced Activity utilities for backward compatibility
+import { createActivityFilter, createLastInteractionFilter, } from './builders.js';
+export const Activity = {
+    createActivityFilter,
+    createLastInteractionFilter,
+};
+// Re-export namespaced Relationship utilities for backward compatibility
+import { applyRateLimit, createPeopleByCompanyFilter, createCompaniesByPeopleFilter, createRecordsByListFilter, createPeopleByCompanyListFilter, createCompaniesByPeopleListFilter, createRecordsByNotesFilter, } from './relationship.js';
+export const Relationship = {
+    applyRateLimit,
+    createPeopleByCompanyFilter,
+    createCompaniesByPeopleFilter,
+    createRecordsByListFilter,
+    createPeopleByCompanyListFilter,
+    createCompaniesByPeopleListFilter,
+    createRecordsByNotesFilter,
+};
+// Legacy exports for backward compatibility
+import { combineFiltersWithAnd, combineFiltersWithOr } from './builders.js';
+export { transformFiltersToApiFormat, createEqualsFilter, createContainsFilter, combineFiltersWithAnd, combineFiltersWithOr, createDateRangeFilter, createCreatedDateFilter, createModifiedDateFilter, createNumericFilter, createRevenueFilter, createEmployeeCountFilter, createLastInteractionFilter, createActivityFilter, 
+// Relationship filters
+createPeopleByCompanyFilter, createCompaniesByPeopleFilter, createRecordsByListFilter, createPeopleByCompanyListFilter, createCompaniesByPeopleListFilter, createRecordsByNotesFilter, };
+// Re-export ATTRIBUTES as FILTER_ATTRIBUTES for backward compatibility
+export { ATTRIBUTES as FILTER_ATTRIBUTES } from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/utils/filters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/filters/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,mBAAmB;AACnB,cAAc,YAAY,CAAC;AAE3B,wBAAwB;AACxB,cAAc,iBAAiB,CAAC;AAEhC,sBAAsB;AACtB,cAAc,eAAe,CAAC;AAE9B,yBAAyB;AACzB,cAAc,kBAAkB,CAAC;AAEjC,uBAAuB;AACvB,cAAc,gBAAgB,CAAC;AAE/B,uBAAuB;AACvB,cAAc,YAAY,CAAC;AAE3B,yBAAyB;AACzB,cAAc,YAAY,CAAC;AAE3B,gCAAgC;AAChC,cAAc,mBAAmB,CAAC;AAElC,kEAAkE;AAClE,OAAO,EAAE,2BAA2B,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,cAAc,EACd,aAAa,GACd,MAAM,eAAe,CAAC;AAEvB,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,uBAAuB;IACvB,2BAA2B;IAC3B,kBAAkB;IAClB,oBAAoB;IACpB,cAAc;IACd,aAAa;CACd,CAAC;AAEF,kEAAkE;AAClE,OAAO,EACL,qBAAqB,EACrB,uBAAuB,EACvB,wBAAwB,EACxB,mBAAmB,EACnB,mBAAmB,EACnB,yBAAyB,GAC1B,MAAM,eAAe,CAAC;AAEvB,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,qBAAqB;IACrB,uBAAuB;IACvB,wBAAwB;IACxB,mBAAmB;IACnB,mBAAmB;IACnB,yBAAyB;CAC1B,CAAC;AAEF,qEAAqE;AACrE,OAAO,EACL,oBAAoB,EACpB,2BAA2B,GAC5B,MAAM,eAAe,CAAC;AAEvB,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,oBAAoB;IACpB,2BAA2B;CAC5B,CAAC;AAEF,yEAAyE;AACzE,OAAO,EACL,cAAc,EACd,2BAA2B,EAC3B,6BAA6B,EAC7B,yBAAyB,EACzB,+BAA+B,EAC/B,iCAAiC,EACjC,0BAA0B,GAC3B,MAAM,mBAAmB,CAAC;AAE3B,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,cAAc;IACd,2BAA2B;IAC3B,6BAA6B;IAC7B,yBAAyB;IACzB,+BAA+B;IAC/B,iCAAiC;IACjC,0BAA0B;CAC3B,CAAC;AAEF,4CAA4C;AAC5C,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE5E,OAAO,EACL,2BAA2B,EAC3B,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,wBAAwB,EACxB,mBAAmB,EACnB,mBAAmB,EACnB,yBAAyB,EACzB,2BAA2B,EAC3B,oBAAoB;AACpB,uBAAuB;AACvB,2BAA2B,EAC3B,6BAA6B,EAC7B,yBAAyB,EACzB,+BAA+B,EAC/B,iCAAiC,EACjC,0BAA0B,GAC3B,CAAC;AAEF,uEAAuE;AACvE,OAAO,EAAE,UAAU,IAAI,iBAAiB,EAAE,MAAM,YAAY,CAAC"}

package/dist/utils/filters/operators.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Filter operator implementations and utilities
+ * Provides functionality for working with logical and comparison operators
+ */
+import { ListEntryFilters, FilterConditionType } from './types.js';
+/**
+ * Checks if an operator is supported for a specific field
+ *
+ * @param fieldSlug - The field slug to check
+ * @param operator - The operator to validate
+ * @returns True if the operator is supported for the field
+ */
+export declare function isOperatorSupportedForField(fieldSlug: string, operator: string): boolean;
+/**
+ * Maps a generic operator to a field-specific operator
+ *
+ * @param fieldSlug - The field slug
+ * @param operator - The generic operator
+ * @returns The mapped operator for the specific field
+ */
+export declare function mapOperatorForField(fieldSlug: string, operator: string): string;
+/**
+ * Inverts a filter condition (returns the opposite condition)
+ *
+ * @param condition - The condition to invert
+ * @returns The inverted condition
+ */
+export declare function invertCondition(condition: FilterConditionType): FilterConditionType;
+/**
+ * Creates a NOT filter by inverting all conditions in the given filters
+ *
+ * @param filters - The filters to negate
+ * @returns Negated filter set
+ */
+export declare function createNotFilter(filters: ListEntryFilters): ListEntryFilters;
+/**
+ * Checks if a condition requires a value
+ *
+ * @param condition - The condition to check
+ * @returns True if the condition requires a value
+ */
+export declare function conditionRequiresValue(condition: FilterConditionType): boolean;
+/**
+ * Gets the comparison type for a filter condition
+ *
+ * @param condition - The filter condition
+ * @returns The comparison type (equality, range, text, etc.)
+ */
+export declare function getComparisonType(condition: FilterConditionType): string;
+/**
+ * Determines if two filter conditions are compatible for combination
+ *
+ * @param condition1 - First condition
+ * @param condition2 - Second condition
+ * @returns True if conditions can be combined
+ */
+export declare function areConditionsCompatible(condition1: FilterConditionType, condition2: FilterConditionType): boolean;
+/**
+ * Simplifies a filter by combining compatible conditions
+ *
+ * @param filters - The filters to simplify
+ * @returns Simplified filter set
+ */
+export declare function simplifyFilters(filters: ListEntryFilters): ListEntryFilters;
+//# sourceMappingURL=operators.d.ts.map

package/dist/utils/filters/operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../../../src/utils/filters/operators.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,gBAAgB,EAEhB,mBAAmB,EAEpB,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAUT;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,MAAM,CASR;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,mBAAmB,GAC7B,mBAAmB,CAiBrB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,gBAAgB,CAc3E;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,mBAAmB,GAC7B,OAAO,CAST;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,mBAAmB,GAAG,MAAM,CAiCxE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,mBAAmB,EAC/B,UAAU,EAAE,mBAAmB,GAC9B,OAAO,CAeT;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,gBAAgB,CA6D3E"}

package/dist/utils/filters/operators.js

@@ -0,0 +1,214 @@
+/**
+ * Filter operator implementations and utilities
+ * Provides functionality for working with logical and comparison operators
+ */
+import { FilterConditionType, FIELD_SPECIAL_HANDLING, } from './types.js';
+/**
+ * Checks if an operator is supported for a specific field
+ *
+ * @param fieldSlug - The field slug to check
+ * @param operator - The operator to validate
+ * @returns True if the operator is supported for the field
+ */
+export function isOperatorSupportedForField(fieldSlug, operator) {
+    const specialHandling = FIELD_SPECIAL_HANDLING[fieldSlug];
+    if (!specialHandling || !specialHandling.operators) {
+        // No special handling defined, assume all operators are supported
+        return true;
+    }
+    // Check if the operator is in the allowed list
+    return specialHandling.operators.includes(operator);
+}
+/**
+ * Maps a generic operator to a field-specific operator
+ *
+ * @param fieldSlug - The field slug
+ * @param operator - The generic operator
+ * @returns The mapped operator for the specific field
+ */
+export function mapOperatorForField(fieldSlug, operator) {
+    const specialHandling = FIELD_SPECIAL_HANDLING[fieldSlug];
+    if (!specialHandling) {
+        return operator;
+    }
+    // Check if there's a mapping for this operator
+    return specialHandling[operator] || operator;
+}
+/**
+ * Inverts a filter condition (returns the opposite condition)
+ *
+ * @param condition - The condition to invert
+ * @returns The inverted condition
+ */
+export function invertCondition(condition) {
+    const inversionMap = {
+        [FilterConditionType.EQUALS]: FilterConditionType.NOT_EQUALS,
+        [FilterConditionType.NOT_EQUALS]: FilterConditionType.EQUALS,
+        [FilterConditionType.CONTAINS]: FilterConditionType.NOT_CONTAINS,
+        [FilterConditionType.NOT_CONTAINS]: FilterConditionType.CONTAINS,
+        [FilterConditionType.GREATER_THAN]: FilterConditionType.LESS_THAN_OR_EQUALS,
+        [FilterConditionType.GREATER_THAN_OR_EQUALS]: FilterConditionType.LESS_THAN,
+        [FilterConditionType.LESS_THAN]: FilterConditionType.GREATER_THAN_OR_EQUALS,
+        [FilterConditionType.LESS_THAN_OR_EQUALS]: FilterConditionType.GREATER_THAN,
+        [FilterConditionType.IS_EMPTY]: FilterConditionType.IS_NOT_EMPTY,
+        [FilterConditionType.IS_NOT_EMPTY]: FilterConditionType.IS_EMPTY,
+    };
+    return inversionMap[condition] || condition;
+}
+/**
+ * Creates a NOT filter by inverting all conditions in the given filters
+ *
+ * @param filters - The filters to negate
+ * @returns Negated filter set
+ */
+export function createNotFilter(filters) {
+    const negatedFilters = (filters.filters &&
+        filters.filters.map((filter) => ({
+            ...filter,
+            condition: invertCondition(filter.condition),
+        }))) ||
+        [];
+    return {
+        filters: negatedFilters,
+        // Invert the matchAny logic as well
+        matchAny: !filters.matchAny,
+    };
+}
+/**
+ * Checks if a condition requires a value
+ *
+ * @param condition - The condition to check
+ * @returns True if the condition requires a value
+ */
+export function conditionRequiresValue(condition) {
+    const noValueConditions = [
+        FilterConditionType.IS_EMPTY,
+        FilterConditionType.IS_NOT_EMPTY,
+        FilterConditionType.IS_SET,
+        FilterConditionType.IS_NOT_SET,
+    ];
+    return !noValueConditions.includes(condition);
+}
+/**
+ * Gets the comparison type for a filter condition
+ *
+ * @param condition - The filter condition
+ * @returns The comparison type (equality, range, text, etc.)
+ */
+export function getComparisonType(condition) {
+    const equalityConditions = [
+        FilterConditionType.EQUALS,
+        FilterConditionType.NOT_EQUALS,
+    ];
+    const rangeConditions = [
+        FilterConditionType.GREATER_THAN,
+        FilterConditionType.GREATER_THAN_OR_EQUALS,
+        FilterConditionType.LESS_THAN,
+        FilterConditionType.LESS_THAN_OR_EQUALS,
+    ];
+    const textConditions = [
+        FilterConditionType.CONTAINS,
+        FilterConditionType.NOT_CONTAINS,
+        FilterConditionType.STARTS_WITH,
+        FilterConditionType.ENDS_WITH,
+    ];
+    const existenceConditions = [
+        FilterConditionType.IS_EMPTY,
+        FilterConditionType.IS_NOT_EMPTY,
+        FilterConditionType.IS_SET,
+        FilterConditionType.IS_NOT_SET,
+    ];
+    if (equalityConditions.includes(condition))
+        return 'equality';
+    if (rangeConditions.includes(condition))
+        return 'range';
+    if (textConditions.includes(condition))
+        return 'text';
+    if (existenceConditions.includes(condition))
+        return 'existence';
+    return 'unknown';
+}
+/**
+ * Determines if two filter conditions are compatible for combination
+ *
+ * @param condition1 - First condition
+ * @param condition2 - Second condition
+ * @returns True if conditions can be combined
+ */
+export function areConditionsCompatible(condition1, condition2) {
+    const type1 = getComparisonType(condition1);
+    const type2 = getComparisonType(condition2);
+    // Same types are generally compatible
+    if (type1 === type2)
+        return true;
+    // Range conditions can be combined (e.g., greater than AND less than)
+    if (type1 === 'range' && type2 === 'range')
+        return true;
+    // Existence conditions cannot be combined with value conditions
+    if (type1 === 'existence' || type2 === 'existence')
+        return false;
+    // Default to incompatible
+    return false;
+}
+/**
+ * Simplifies a filter by combining compatible conditions
+ *
+ * @param filters - The filters to simplify
+ * @returns Simplified filter set
+ */
+export function simplifyFilters(filters) {
+    const simplifiedFilters = [];
+    const filterMap = new Map();
+    // Group filters by attribute
+    filters.filters &&
+        filters.filters.forEach((filter) => {
+            const key = filter.attribute.slug;
+            if (!filterMap.has(key)) {
+                filterMap.set(key, []);
+            }
+            filterMap.get(key).push(filter);
+        });
+    // Simplify each group
+    filterMap.forEach((filterGroup, _attribute) => {
+        if (filterGroup.length === 1) {
+            // Single filter, no simplification needed
+            simplifiedFilters.push(...filterGroup);
+        }
+        else {
+            // Multiple filters for same attribute, check if they can be combined
+            const rangeFilters = filterGroup.filter((f) => getComparisonType(f.condition) === 'range');
+            if (rangeFilters.length === 2) {
+                // Potentially combinable range filters
+                const [filter1, filter2] = rangeFilters;
+                // Check for min/max combination
+                if ((filter1.condition === FilterConditionType.GREATER_THAN ||
+                    filter1.condition === FilterConditionType.GREATER_THAN_OR_EQUALS) &&
+                    (filter2.condition === FilterConditionType.LESS_THAN ||
+                        filter2.condition === FilterConditionType.LESS_THAN_OR_EQUALS)) {
+                    // This is a valid range, keep both
+                    simplifiedFilters.push(filter1, filter2);
+                }
+                else if ((filter2.condition === FilterConditionType.GREATER_THAN ||
+                    filter2.condition === FilterConditionType.GREATER_THAN_OR_EQUALS) &&
+                    (filter1.condition === FilterConditionType.LESS_THAN ||
+                        filter1.condition === FilterConditionType.LESS_THAN_OR_EQUALS)) {
+                    // This is a valid range, keep both
+                    simplifiedFilters.push(filter1, filter2);
+                }
+                else {
+                    // Incompatible range conditions, keep all
+                    simplifiedFilters.push(...filterGroup);
+                }
+            }
+            else {
+                // Cannot simplify, keep all filters
+                simplifiedFilters.push(...filterGroup);
+            }
+        }
+    });
+    return {
+        filters: simplifiedFilters,
+        matchAny: filters.matchAny,
+    };
+}
+//# sourceMappingURL=operators.js.map

package/dist/utils/filters/operators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.js","sourceRoot":"","sources":["../../../src/utils/filters/operators.ts"],"names":[],"mappings":"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"}

package/dist/utils/filters/relationship.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Relationship filtering utilities
+ * These utilities help create filters based on relationships between records
+ */
+import { ListEntryFilters, ResourceType } from './types.js';
+/**
+ * Applies rate limiting to relationship queries
+ * Throws RelationshipRateLimitError if the rate limit is exceeded
+ *
+ * @param req - Request object
+ * @param relationshipType - Type of relationship query
+ * @param isNested - Whether this is a nested relationship query
+ * @throws RelationshipRateLimitError if rate limit exceeded
+ */
+export declare function applyRateLimit(req: any, relationshipType: string, isNested?: boolean): void;
+/**
+ * Creates a filter for people based on their associated company attributes
+ * Includes rate limiting for this resource-intensive operation
+ *
+ * @param companyFilter - Filters to apply to the related companies
+ * @param req - Optional request object for rate limiting (if not provided, rate limiting is skipped)
+ * @returns Filter for finding people based on company attributes
+ * @throws RelationshipRateLimitError if rate limit exceeded
+ */
+export declare function createPeopleByCompanyFilter(companyFilter: ListEntryFilters, req?: any): ListEntryFilters;
+/**
+ * Creates a filter for companies based on their associated people attributes
+ * Includes rate limiting for this resource-intensive operation
+ *
+ * @param peopleFilter - Filters to apply to the related people
+ * @param req - Optional request object for rate limiting (if not provided, rate limiting is skipped)
+ * @returns Filter for finding companies based on people attributes
+ * @throws RelationshipRateLimitError if rate limit exceeded
+ */
+export declare function createCompaniesByPeopleFilter(peopleFilter: ListEntryFilters, req?: any): ListEntryFilters;
+/**
+ * Creates a filter for records that belong to a specific list
+ * Includes rate limiting for this operation and caching for better performance
+ *
+ * @param resourceType - The type of records to filter (people or companies)
+ * @param listId - The ID of the list to filter by
+ * @param req - Optional request object for rate limiting (if not provided, rate limiting is skipped)
+ * @param useCache - Whether to use caching (default: true)
+ * @returns Filter for finding records that belong to the list
+ * @throws RelationshipRateLimitError if rate limit exceeded
+ */
+export declare function createRecordsByListFilter(resourceType: ResourceType, listId: string, req?: any, useCache?: boolean): ListEntryFilters;
+/**
+ * Creates a filter for finding people who work at companies in a specific list
+ * This is a nested relationship query with rate limiting and caching applied
+ *
+ * @param listId - The ID of the list that contains companies
+ * @param req - Optional request object for rate limiting (if not provided, rate limiting is skipped)
+ * @param useCache - Whether to use caching (default: true)
+ * @returns Filter for finding people who work at companies in the specified list
+ * @throws RelationshipRateLimitError if rate limit exceeded
+ */
+export declare function createPeopleByCompanyListFilter(listId: string, req?: any, useCache?: boolean): ListEntryFilters;
+/**
+ * Creates a filter for finding companies that have people in a specific list
+ * This is a nested relationship query with rate limiting and caching applied
+ *
+ * @param listId - The ID of the list that contains people
+ * @param req - Optional request object for rate limiting (if not provided, rate limiting is skipped)
+ * @param useCache - Whether to use caching (default: true)
+ * @returns Filter for finding companies that have people in the specified list
+ * @throws RelationshipRateLimitError if rate limit exceeded
+ */
+export declare function createCompaniesByPeopleListFilter(listId: string, req?: any, useCache?: boolean): ListEntryFilters;
+/**
+ * Creates a filter for records that have associated notes matching criteria
+ * Includes rate limiting for text search operations
+ *
+ * @param resourceType - The type of records to filter (people or companies)
+ * @param textSearch - Text to search for in the notes
+ * @param req - Optional request object for rate limiting (if not provided, rate limiting is skipped)
+ * @returns Filter for finding records with matching notes
+ * @throws RelationshipRateLimitError if rate limit exceeded
+ */
+export declare function createRecordsByNotesFilter(resourceType: ResourceType, textSearch: string, req?: any): ListEntryFilters;
+//# sourceMappingURL=relationship.d.ts.map

package/dist/utils/filters/relationship.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationship.d.ts","sourceRoot":"","sources":["../../../src/utils/filters/relationship.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,OAAO,EACL,gBAAgB,EAGhB,YAAY,EAIb,MAAM,YAAY,CAAC;AAWpB;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,GAAG,EACR,gBAAgB,EAAE,MAAM,EACxB,QAAQ,GAAE,OAAe,GACxB,IAAI,CAaN;AAiDD;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,gBAAgB,EAC/B,GAAG,CAAC,EAAE,GAAG,GACR,gBAAgB,CAgDlB;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAC3C,YAAY,EAAE,gBAAgB,EAC9B,GAAG,CAAC,EAAE,GAAG,GACR,gBAAgB,CAgDlB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,GAAG,EACT,QAAQ,GAAE,OAAc,GACvB,gBAAgB,CAgElB;AAED;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,GAAG,EACT,QAAQ,GAAE,OAAc,GACvB,gBAAgB,CAkElB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,GAAG,EACT,QAAQ,GAAE,OAAc,GACvB,gBAAgB,CAkElB;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,YAAY,EAC1B,UAAU,EAAE,MAAM,EAClB,GAAG,CAAC,EAAE,GAAG,GACR,gBAAgB,CAyClB"}