@skmtc/core 0.0.983 → 0.16.1

package/esm/typescript/PathParams.d.ts

@@ -1,218 +0,0 @@
-import type { GenerateContext } from '../context/GenerateContext.js';
-import { Definition } from '../dsl/Definition.js';
-import type { TypeSystemObject } from '../types/TypeSystem.js';
-import { FunctionParameter } from './FunctionParameter.js';
-/**
- * Constructor arguments for {@link PathParams}.
- */
-type ConstructorArgs = {
-    /** The generation context for registering types and handling imports */
-    context: GenerateContext;
-    /** Optional argument name for the parameter (if undefined, uses destructuring) */
-    argName?: string;
-    /** Name of the TypeScript type to generate */
-    typeName: string;
-    /** The type system object defining the parameter structure */
-    typeValue: TypeSystemObject;
-    /** OpenAPI path template with parameter placeholders */
-    pathTemplate: string;
-};
-/**
- * Manages path parameter type definitions and function parameters for API endpoints.
- *
- * `PathParams` is a utility class that combines type generation, function parameter
- * handling, and path templating for OpenAPI path parameters. It creates TypeScript
- * type definitions for path parameters and generates the corresponding function
- * parameters that can be used in API client methods.
- *
- * This class is essential for generating type-safe API clients where path parameters
- * are properly typed and validated at compile time. It handles both destructured
- * parameters (when no argument name is provided) and named parameters.
- *
- * ## Key Features
- *
- * - **Type Definition Generation**: Creates TypeScript types for path parameters
- * - **Function Parameter Integration**: Generates properly typed function parameters
- * - **Path Template Processing**: Converts OpenAPI paths to template literals
- * - **Destructuring Support**: Handles both named and destructured parameter patterns
- * - **Context Integration**: Fully integrated with the SKMTC generation pipeline
- *
- * @example Basic path parameters with destructuring
- * ```typescript
- * import { PathParams } from '@skmtc/core';
- *
- * const pathParams = new PathParams({
- *   context: generateContext,
- *   typeName: 'GetUserParams',
- *   typeValue: {
- *     type: 'object',
- *     objectProperties: {
- *       properties: {
- *         id: { type: 'string' },
- *         format: { type: 'string' }
- *       }
- *     }
- *   },
- *   pathTemplate: '/users/{id}'
- * });
- *
- * console.log(pathParams.path); // '/users/${id}'
- * ```
- *
- * @example Named parameter usage
- * ```typescript
- * const namedPathParams = new PathParams({
- *   context: generateContext,
- *   argName: 'params',
- *   typeName: 'UserPathParams',
- *   typeValue: {
- *     type: 'object',
- *     objectProperties: {
- *       properties: {
- *         userId: { type: 'string' },
- *         projectId: { type: 'string' }
- *       }
- *     }
- *   },
- *   pathTemplate: '/users/{userId}/projects/{projectId}'
- * });
- *
- * console.log(pathParams.path); // '/users/${params.userId}/projects/${params.projectId}'
- * ```
- *
- * @example API client method generation
- * ```typescript
- * class ApiMethodGenerator {
- *   generateGetMethod(operationPath: string, parameters: any) {
- *     const pathParams = new PathParams({
- *       context: this.context,
- *       argName: 'pathParams',
- *       typeName: 'PathParameters',
- *       typeValue: parameters,
- *       pathTemplate: operationPath
- *     });
- *
- *     return `
- * async getData(${pathParams.parameter.toString()}) {
- *   const url = \`${pathParams.path}\`;
- *   return this.client.get(url);
- * }`;
- *   }
- * }
- *
- * // Generates:
- * // async getData(pathParams: PathParameters) {
- * //   const url = `/users/${pathParams.userId}/projects/${pathParams.projectId}`;
- * //   return this.client.get(url);
- * // }
- * ```
- *
- * @example With destructured parameters
- * ```typescript
- * const destructuredParams = new PathParams({
- *   context: generateContext,
- *   // No argName provided, so uses destructuring
- *   typeName: 'OrderParams',
- *   typeValue: {
- *     type: 'object',
- *     objectProperties: {
- *       properties: {
- *         orderId: { type: 'string' },
- *         customerId: { type: 'string' }
- *       }
- *     }
- *   },
- *   pathTemplate: '/customers/{customerId}/orders/{orderId}'
- * });
- *
- * // Function parameter will be: { orderId, customerId }: OrderParams
- * // Path template will be: '/customers/${customerId}/orders/${orderId}'
- * ```
- *
- * @example Complex nested path parameters
- * ```typescript
- * const complexPathParams = new PathParams({
- *   context: generateContext,
- *   argName: 'pathData',
- *   typeName: 'ComplexPathParams',
- *   typeValue: {
- *     type: 'object',
- *     objectProperties: {
- *       properties: {
- *         orgId: { type: 'string' },
- *         projectId: { type: 'string' },
- *         issueId: { type: 'number' },
- *         commentId: { type: 'string' }
- *       }
- *     }
- *   },
- *   pathTemplate: '/orgs/{orgId}/projects/{projectId}/issues/{issueId}/comments/{commentId}'
- * });
- *
- * // Generates path: '/orgs/${pathData.orgId}/projects/${pathData.projectId}/issues/${pathData.issueId}/comments/${pathData.commentId}'
- * ```
- *
- * @example Integration with operation generation
- * ```typescript
- * class OperationGenerator {
- *   generateOperation(operation: OasOperation) {
- *     const pathParameters = this.extractPathParameters(operation);
- *
- *     if (pathParameters.length > 0) {
- *       const pathParams = new PathParams({
- *         context: this.context,
- *         typeName: `${operation.operationId}PathParams`,
- *         typeValue: this.buildParametersType(pathParameters),
- *         pathTemplate: operation.path
- *       });
- *
- *       return this.generateMethodWithPathParams(operation, pathParams);
- *     }
- *
- *     return this.generateSimpleMethod(operation);
- *   }
- * }
- * ```
- */
-export declare class PathParams {
-    /** The generation context used for type registration and imports */
-    context: GenerateContext;
-    /** The TypeScript type definition for the path parameters */
-    typeDefinition: Definition<TypeSystemObject>;
-    /** The function parameter representation for method signatures */
-    parameter: FunctionParameter;
-    /** The processed path template with parameter substitutions */
-    path: string;
-    /**
-     * Creates a new PathParams instance with type definitions and path processing.
-     *
-     * The constructor sets up the complete parameter handling pipeline:
-     * 1. Creates a TypeScript type definition for the parameters
-     * 2. Generates a function parameter (either named or destructured)
-     * 3. Processes the path template for runtime interpolation
-     *
-     * @param args - Configuration for path parameter generation
-     *
-     * @example
-     * ```typescript
-     * const pathParams = new PathParams({
-     *   context: generateContext,
-     *   argName: 'params',
-     *   typeName: 'UserPathParams',
-     *   typeValue: {
-     *     type: 'object',
-     *     objectProperties: {
-     *       properties: {
-     *         id: { type: 'string' },
-     *         format: { type: 'string' }
-     *       }
-     *     }
-     *   },
-     *   pathTemplate: '/users/{id}/profile'
-     * });
-     * ```
-     */
-    constructor({ context, argName, typeName, typeValue, pathTemplate }: ConstructorArgs);
-}
-export {};
-//# sourceMappingURL=PathParams.d.ts.map

package/esm/typescript/PathParams.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PathParams.d.ts","sourceRoot":"","sources":["../../src/typescript/PathParams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AACpE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAEjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAG1D;;GAEG;AACH,KAAK,eAAe,GAAG;IACrB,wEAAwE;IACxE,OAAO,EAAE,eAAe,CAAA;IACxB,kFAAkF;IAClF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAA;IAChB,8DAA8D;IAC9D,SAAS,EAAE,gBAAgB,CAAA;IAC3B,wDAAwD;IACxD,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4JG;AACH,qBAAa,UAAU;IACrB,oEAAoE;IACpE,OAAO,EAAE,eAAe,CAAA;IAExB,6DAA6D;IAC7D,cAAc,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAA;IAE5C,kEAAkE;IAClE,SAAS,EAAE,iBAAiB,CAAA;IAE5B,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAA;IAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;gBACS,EACV,OAAO,EACP,OAAO,EACP,QAAQ,EACR,SAAS,EACT,YAAY,EACb,EAAE,eAAe;CAwBnB"}

package/esm/typescript/PathParams.js

@@ -1,239 +0,0 @@
-import { Definition } from '../dsl/Definition.js';
-import { Identifier } from '../dsl/Identifier.js';
-import { FunctionParameter } from './FunctionParameter.js';
-import { toPathTemplate } from './toPathTemplate.js';
-/**
- * Manages path parameter type definitions and function parameters for API endpoints.
- *
- * `PathParams` is a utility class that combines type generation, function parameter
- * handling, and path templating for OpenAPI path parameters. It creates TypeScript
- * type definitions for path parameters and generates the corresponding function
- * parameters that can be used in API client methods.
- *
- * This class is essential for generating type-safe API clients where path parameters
- * are properly typed and validated at compile time. It handles both destructured
- * parameters (when no argument name is provided) and named parameters.
- *
- * ## Key Features
- *
- * - **Type Definition Generation**: Creates TypeScript types for path parameters
- * - **Function Parameter Integration**: Generates properly typed function parameters
- * - **Path Template Processing**: Converts OpenAPI paths to template literals
- * - **Destructuring Support**: Handles both named and destructured parameter patterns
- * - **Context Integration**: Fully integrated with the SKMTC generation pipeline
- *
- * @example Basic path parameters with destructuring
- * ```typescript
- * import { PathParams } from '@skmtc/core';
- *
- * const pathParams = new PathParams({
- *   context: generateContext,
- *   typeName: 'GetUserParams',
- *   typeValue: {
- *     type: 'object',
- *     objectProperties: {
- *       properties: {
- *         id: { type: 'string' },
- *         format: { type: 'string' }
- *       }
- *     }
- *   },
- *   pathTemplate: '/users/{id}'
- * });
- *
- * console.log(pathParams.path); // '/users/${id}'
- * ```
- *
- * @example Named parameter usage
- * ```typescript
- * const namedPathParams = new PathParams({
- *   context: generateContext,
- *   argName: 'params',
- *   typeName: 'UserPathParams',
- *   typeValue: {
- *     type: 'object',
- *     objectProperties: {
- *       properties: {
- *         userId: { type: 'string' },
- *         projectId: { type: 'string' }
- *       }
- *     }
- *   },
- *   pathTemplate: '/users/{userId}/projects/{projectId}'
- * });
- *
- * console.log(pathParams.path); // '/users/${params.userId}/projects/${params.projectId}'
- * ```
- *
- * @example API client method generation
- * ```typescript
- * class ApiMethodGenerator {
- *   generateGetMethod(operationPath: string, parameters: any) {
- *     const pathParams = new PathParams({
- *       context: this.context,
- *       argName: 'pathParams',
- *       typeName: 'PathParameters',
- *       typeValue: parameters,
- *       pathTemplate: operationPath
- *     });
- *
- *     return `
- * async getData(${pathParams.parameter.toString()}) {
- *   const url = \`${pathParams.path}\`;
- *   return this.client.get(url);
- * }`;
- *   }
- * }
- *
- * // Generates:
- * // async getData(pathParams: PathParameters) {
- * //   const url = `/users/${pathParams.userId}/projects/${pathParams.projectId}`;
- * //   return this.client.get(url);
- * // }
- * ```
- *
- * @example With destructured parameters
- * ```typescript
- * const destructuredParams = new PathParams({
- *   context: generateContext,
- *   // No argName provided, so uses destructuring
- *   typeName: 'OrderParams',
- *   typeValue: {
- *     type: 'object',
- *     objectProperties: {
- *       properties: {
- *         orderId: { type: 'string' },
- *         customerId: { type: 'string' }
- *       }
- *     }
- *   },
- *   pathTemplate: '/customers/{customerId}/orders/{orderId}'
- * });
- *
- * // Function parameter will be: { orderId, customerId }: OrderParams
- * // Path template will be: '/customers/${customerId}/orders/${orderId}'
- * ```
- *
- * @example Complex nested path parameters
- * ```typescript
- * const complexPathParams = new PathParams({
- *   context: generateContext,
- *   argName: 'pathData',
- *   typeName: 'ComplexPathParams',
- *   typeValue: {
- *     type: 'object',
- *     objectProperties: {
- *       properties: {
- *         orgId: { type: 'string' },
- *         projectId: { type: 'string' },
- *         issueId: { type: 'number' },
- *         commentId: { type: 'string' }
- *       }
- *     }
- *   },
- *   pathTemplate: '/orgs/{orgId}/projects/{projectId}/issues/{issueId}/comments/{commentId}'
- * });
- *
- * // Generates path: '/orgs/${pathData.orgId}/projects/${pathData.projectId}/issues/${pathData.issueId}/comments/${pathData.commentId}'
- * ```
- *
- * @example Integration with operation generation
- * ```typescript
- * class OperationGenerator {
- *   generateOperation(operation: OasOperation) {
- *     const pathParameters = this.extractPathParameters(operation);
- *
- *     if (pathParameters.length > 0) {
- *       const pathParams = new PathParams({
- *         context: this.context,
- *         typeName: `${operation.operationId}PathParams`,
- *         typeValue: this.buildParametersType(pathParameters),
- *         pathTemplate: operation.path
- *       });
- *
- *       return this.generateMethodWithPathParams(operation, pathParams);
- *     }
- *
- *     return this.generateSimpleMethod(operation);
- *   }
- * }
- * ```
- */
-export class PathParams {
-    /**
-     * Creates a new PathParams instance with type definitions and path processing.
-     *
-     * The constructor sets up the complete parameter handling pipeline:
-     * 1. Creates a TypeScript type definition for the parameters
-     * 2. Generates a function parameter (either named or destructured)
-     * 3. Processes the path template for runtime interpolation
-     *
-     * @param args - Configuration for path parameter generation
-     *
-     * @example
-     * ```typescript
-     * const pathParams = new PathParams({
-     *   context: generateContext,
-     *   argName: 'params',
-     *   typeName: 'UserPathParams',
-     *   typeValue: {
-     *     type: 'object',
-     *     objectProperties: {
-     *       properties: {
-     *         id: { type: 'string' },
-     *         format: { type: 'string' }
-     *       }
-     *     }
-     *   },
-     *   pathTemplate: '/users/{id}/profile'
-     * });
-     * ```
-     */
-    constructor({ context, argName, typeName, typeValue, pathTemplate }) {
-        /** The generation context used for type registration and imports */
-        Object.defineProperty(this, "context", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** The TypeScript type definition for the path parameters */
-        Object.defineProperty(this, "typeDefinition", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** The function parameter representation for method signatures */
-        Object.defineProperty(this, "parameter", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** The processed path template with parameter substitutions */
-        Object.defineProperty(this, "path", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.context = context;
-        this.typeDefinition = new Definition({
-            context,
-            identifier: Identifier.createType(typeName),
-            value: typeValue
-        });
-        this.parameter = new FunctionParameter({
-            name: argName,
-            typeDefinition: this.typeDefinition,
-            destructure: !argName,
-            required: true
-        });
-        const queryArg = this.parameter.properties.type === 'regular'
-            ? this.parameter.properties.name
-            : undefined;
-        // @TODO Reconcile pathTemplate with params
-        this.path = toPathTemplate(pathTemplate, queryArg);
-    }
-}

package/esm/typescript/ReactRouterPathParams.d.ts

@@ -1,210 +0,0 @@
-import { ContentBase } from '../dsl/ContentBase.js';
-import type { GenerateContext } from '../context/GenerateContext.js';
-import type { OasOperation } from '../oas/operation/Operation.js';
-import type { GeneratorKey } from '../dsl/GeneratorKeys.js';
-/**
- * Constructor arguments for {@link ReactRouterPathParams}.
- */
-type CreateArgs = {
-    /** The generation context for registering imports and handling dependencies */
-    context: GenerateContext;
-    /** The generator key identifying this component */
-    generatorKey: GeneratorKey;
-    /** The OpenAPI operation containing path parameters */
-    operation: OasOperation;
-    /** The destination file path for import registration */
-    destinationPath: string;
-};
-/**
- * Generates React Router path parameter handling code for OpenAPI operations.
- *
- * `ReactRouterPathParams` is a specialized content generator that creates the necessary
- * React code for extracting and validating path parameters from React Router's `useParams`
- * hook. It automatically generates parameter extraction, assertion logic, and prop passing
- * code based on OpenAPI operation path parameters.
- *
- * This class is essential for generating type-safe React components that need to access
- * URL path parameters, ensuring runtime validation and proper TypeScript typing. It
- * integrates with React Router's `useParams` hook and adds runtime assertions using
- * the `tiny-invariant` library.
- *
- * ## Key Features
- *
- * - **Automatic Parameter Extraction**: Generates `useParams()` destructuring code
- * - **Runtime Assertions**: Creates invariant checks for required parameters
- * - **Prop Passing**: Generates prop spreading syntax for component integration
- * - **Import Management**: Automatically registers required imports
- * - **Type Safety**: Ensures parameters are properly validated at runtime
- *
- * @example Basic usage with single path parameter
- * ```typescript
- * import { ReactRouterPathParams } from '@skmtc/core';
- *
- * const operation = new OasOperation({
- *   path: '/users/{id}',
- *   method: 'get',
- *   // ... other operation properties
- * });
- *
- * const pathParams = new ReactRouterPathParams({
- *   context: generateContext,
- *   generatorKey: 'react-router-params',
- *   operation,
- *   destinationPath: './UserDetail.tsx'
- * });
- *
- * console.log(pathParams.getParams);
- * // 'const { id } = useParams()'
- *
- * console.log(pathParams.assertParams);
- * // 'invariant(id, 'Expected id to be defined')'
- *
- * console.log(pathParams.passProps);
- * // 'id={id}'
- * ```
- *
- * @example Multiple path parameters
- * ```typescript
- * const complexOperation = new OasOperation({
- *   path: '/organizations/{orgId}/projects/{projectId}/issues/{issueId}',
- *   method: 'get',
- *   // ... other properties
- * });
- *
- * const multiParams = new ReactRouterPathParams({
- *   context: generateContext,
- *   generatorKey: 'react-router-params',
- *   operation: complexOperation,
- *   destinationPath: './IssueDetail.tsx'
- * });
- *
- * console.log(multiParams.getParams);
- * // 'const { orgId, projectId, issueId } = useParams()'
- *
- * console.log(multiParams.assertParams);
- * // 'invariant(orgId, 'Expected orgId to be defined')
- * // invariant(projectId, 'Expected projectId to be defined')
- * // invariant(issueId, 'Expected issueId to be defined')'
- *
- * console.log(multiParams.passProps);
- * // 'orgId={orgId} projectId={projectId} issueId={issueId}'
- * ```
- *
- * @example Generated React component integration
- * ```typescript
- * // Generated component might look like:
- * import { useParams } from 'react-router-dom';
- * import invariant from 'tiny-invariant';
- *
- * function UserDetail() {
- *   const { id } = useParams();
- *   invariant(id, 'Expected id to be defined');
- *
- *   return <UserDetailView id={id} />;
- * }
- * ```
- *
- * @example No path parameters (empty generation)
- * ```typescript
- * const simpleOperation = new OasOperation({
- *   path: '/users',
- *   method: 'get',
- *   // ... other properties
- * });
- *
- * const emptyParams = new ReactRouterPathParams({
- *   context: generateContext,
- *   generatorKey: 'react-router-params',
- *   operation: simpleOperation,
- *   destinationPath: './UserList.tsx'
- * });
- *
- * console.log(emptyParams.getParams);    // ''
- * console.log(emptyParams.assertParams); // ''
- * console.log(emptyParams.passProps);    // ''
- * // No imports registered for this case
- * ```
- *
- * @example Integration in component generation
- * ```typescript
- * class ReactComponentGenerator {
- *   generateDetailComponent(operation: OasOperation) {
- *     const pathParams = new ReactRouterPathParams({
- *       context: this.context,
- *       generatorKey: 'react-component',
- *       operation,
- *       destinationPath: this.getDestinationPath(operation)
- *     });
- *
- *     if (pathParams.names.length === 0) {
- *       // Generate simple component without parameters
- *       return this.generateSimpleComponent(operation);
- *     }
- *
- *     return `
- * function ${operation.operationId}() {
- *   ${pathParams.getParams}
- *   ${pathParams.assertParams}
- *
- *   return (
- *     <DetailView ${pathParams.passProps} />
- *   );
- * }`;
- *   }
- * }
- * ```
- *
- * @example Custom parameter validation
- * ```typescript
- * class CustomReactRouterParams extends ReactRouterPathParams {
- *   generateCustomAssertions(paramName: string): string {
- *     return `
- * invariant(${paramName}, 'Expected ${paramName} to be defined');
- * invariant(typeof ${paramName} === 'string', '${paramName} must be a string');
- * invariant(${paramName}.length > 0, '${paramName} cannot be empty');`;
- *   }
- * }
- * ```
- */
-export declare class ReactRouterPathParams extends ContentBase {
-    /** Generated code for extracting parameters from useParams() */
-    getParams: string;
-    /** Generated code for runtime parameter assertions */
-    assertParams: string;
-    /** Generated code for passing parameters as component props */
-    passProps: string;
-    /** Array of parameter names extracted from the operation path */
-    names: string[];
-    /**
-     * Creates a new ReactRouterPathParams instance with generated parameter handling code.
-     *
-     * The constructor analyzes the OpenAPI operation to extract path parameters and
-     * generates the necessary React code for parameter extraction, validation, and
-     * prop passing. It automatically registers required imports when parameters are present.
-     *
-     * @param args - Configuration for React Router parameter generation
-     *
-     * @example
-     * ```typescript
-     * const pathParams = new ReactRouterPathParams({
-     *   context: generateContext,
-     *   generatorKey: 'react-params',
-     *   operation: userDetailOperation, // has path '/users/{id}'
-     *   destinationPath: './UserDetail.tsx'
-     * });
-     * ```
-     */
-    constructor({ context, operation, generatorKey, destinationPath }: CreateArgs);
-    /**
-     * Returns an empty string as this class provides code through its properties.
-     *
-     * The ReactRouterPathParams class doesn't generate output through toString(),
-     * instead providing generated code through the `getParams`, `assertParams`,
-     * and `passProps` properties which can be used directly in template generation.
-     *
-     * @returns Empty string
-     */
-    toString(): string;
-}
-export {};
-//# sourceMappingURL=ReactRouterPathParams.d.ts.map

package/esm/typescript/ReactRouterPathParams.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ReactRouterPathParams.d.ts","sourceRoot":"","sources":["../../src/typescript/ReactRouterPathParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAE3D;;GAEG;AACH,KAAK,UAAU,GAAG;IAChB,+EAA+E;IAC/E,OAAO,EAAE,eAAe,CAAA;IACxB,mDAAmD;IACnD,YAAY,EAAE,YAAY,CAAA;IAC1B,uDAAuD;IACvD,SAAS,EAAE,YAAY,CAAA;IACvB,wDAAwD;IACxD,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsJG;AACH,qBAAa,qBAAsB,SAAQ,WAAW;IACpD,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAK;IAEtB,sDAAsD;IACtD,YAAY,EAAE,MAAM,CAAK;IAEzB,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAK;IAEtB,iEAAiE;IACjE,KAAK,EAAE,MAAM,EAAE,CAAA;IAEf;;;;;;;;;;;;;;;;;;OAkBG;gBACS,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,eAAe,EAAE,EAAE,UAAU;IAwB7E;;;;;;;;OAQG;IACM,QAAQ,IAAI,MAAM;CAG5B"}