@defai.digital/contracts 13.0.3

package/dist/file-system/v1/schema.d.ts

@@ -0,0 +1,644 @@
+/**
+ * File System Contracts v1
+ *
+ * Defines schemas for file and directory operations with security invariants.
+ * Used by scaffold tools to write generated code to disk.
+ *
+ * @module @defai.digital/contracts/file-system/v1
+ */
+import { z } from 'zod';
+/**
+ * File path schema with security validation
+ *
+ * Invariants:
+ * - INV-FS-001: No path traversal allowed
+ */
+export declare const FilePathSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+export type FilePath = z.infer<typeof FilePathSchema>;
+/**
+ * File encoding options
+ */
+export declare const FileEncodingSchema: z.ZodEnum<["utf-8", "ascii", "base64", "binary"]>;
+export type FileEncoding = z.infer<typeof FileEncodingSchema>;
+/**
+ * Request to write a file
+ *
+ * Invariants:
+ * - INV-FS-002: No silent overwrites (requires explicit flag)
+ * - INV-FS-004: UTF-8 default encoding
+ */
+export declare const FileWriteRequestSchema: z.ZodObject<{
+    /** Relative path from workspace root */
+    path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    /** File content to write */
+    content: z.ZodString;
+    /** Create parent directories if they don't exist */
+    createDirectories: z.ZodDefault<z.ZodBoolean>;
+    /** Allow overwriting existing files */
+    overwrite: z.ZodDefault<z.ZodBoolean>;
+    /** File encoding */
+    encoding: z.ZodDefault<z.ZodEnum<["utf-8", "ascii", "base64", "binary"]>>;
+    /** Optional backup before overwrite */
+    backup: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    overwrite: boolean;
+    content: string;
+    createDirectories: boolean;
+    encoding: "base64" | "utf-8" | "ascii" | "binary";
+    backup: boolean;
+}, {
+    path: string;
+    content: string;
+    overwrite?: boolean | undefined;
+    createDirectories?: boolean | undefined;
+    encoding?: "base64" | "utf-8" | "ascii" | "binary" | undefined;
+    backup?: boolean | undefined;
+}>;
+export type FileWriteRequest = z.infer<typeof FileWriteRequestSchema>;
+/**
+ * Result of file write operation
+ */
+export declare const FileWriteResultSchema: z.ZodObject<{
+    /** Whether the operation succeeded */
+    success: z.ZodBoolean;
+    /** Path that was written */
+    path: z.ZodString;
+    /** Number of bytes written */
+    bytesWritten: z.ZodNumber;
+    /** Whether a new file was created */
+    created: z.ZodBoolean;
+    /** Whether an existing file was overwritten */
+    overwritten: z.ZodBoolean;
+    /** Backup path if backup was created */
+    backupPath: z.ZodOptional<z.ZodString>;
+    /** Error details if operation failed */
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+    }, {
+        code: string;
+        message: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    success: boolean;
+    created: boolean;
+    bytesWritten: number;
+    overwritten: boolean;
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+    backupPath?: string | undefined;
+}, {
+    path: string;
+    success: boolean;
+    created: boolean;
+    bytesWritten: number;
+    overwritten: boolean;
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+    backupPath?: string | undefined;
+}>;
+export type FileWriteResult = z.infer<typeof FileWriteResultSchema>;
+/**
+ * Request to create a directory
+ */
+export declare const DirectoryCreateRequestSchema: z.ZodObject<{
+    /** Relative path from workspace root */
+    path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    /** Create parent directories if they don't exist */
+    recursive: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    recursive: boolean;
+}, {
+    path: string;
+    recursive?: boolean | undefined;
+}>;
+export type DirectoryCreateRequest = z.infer<typeof DirectoryCreateRequestSchema>;
+/**
+ * Result of directory creation
+ */
+export declare const DirectoryCreateResultSchema: z.ZodObject<{
+    /** Whether the operation succeeded */
+    success: z.ZodBoolean;
+    /** Path that was created */
+    path: z.ZodString;
+    /** Whether a new directory was created */
+    created: z.ZodBoolean;
+    /** Whether the directory already existed */
+    existed: z.ZodBoolean;
+    /** Error details if operation failed */
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+    }, {
+        code: string;
+        message: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    success: boolean;
+    created: boolean;
+    existed: boolean;
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+}, {
+    path: string;
+    success: boolean;
+    created: boolean;
+    existed: boolean;
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+}>;
+export type DirectoryCreateResult = z.infer<typeof DirectoryCreateResultSchema>;
+/**
+ * Request to check if a file exists
+ */
+export declare const FileExistsRequestSchema: z.ZodObject<{
+    /** Relative path from workspace root */
+    path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+export type FileExistsRequest = z.infer<typeof FileExistsRequestSchema>;
+/**
+ * Result of file existence check
+ */
+export declare const FileExistsResultSchema: z.ZodObject<{
+    /** Path that was checked */
+    path: z.ZodString;
+    /** Whether the file exists */
+    exists: z.ZodBoolean;
+    /** Whether it's a file (vs directory) */
+    isFile: z.ZodOptional<z.ZodBoolean>;
+    /** Whether it's a directory */
+    isDirectory: z.ZodOptional<z.ZodBoolean>;
+    /** File size in bytes (if exists and is file) */
+    size: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    exists: boolean;
+    isFile?: boolean | undefined;
+    isDirectory?: boolean | undefined;
+    size?: number | undefined;
+}, {
+    path: string;
+    exists: boolean;
+    isFile?: boolean | undefined;
+    isDirectory?: boolean | undefined;
+    size?: number | undefined;
+}>;
+export type FileExistsResult = z.infer<typeof FileExistsResultSchema>;
+/**
+ * Single file operation in a batch
+ */
+export declare const BatchFileOperationSchema: z.ZodDiscriminatedUnion<"operation", [z.ZodObject<{
+    operation: z.ZodLiteral<"write">;
+    path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    content: z.ZodString;
+    overwrite: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    overwrite: boolean;
+    content: string;
+    operation: "write";
+}, {
+    path: string;
+    content: string;
+    operation: "write";
+    overwrite?: boolean | undefined;
+}>, z.ZodObject<{
+    operation: z.ZodLiteral<"mkdir">;
+    path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    recursive: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    recursive: boolean;
+    operation: "mkdir";
+}, {
+    path: string;
+    operation: "mkdir";
+    recursive?: boolean | undefined;
+}>]>;
+export type BatchFileOperation = z.infer<typeof BatchFileOperationSchema>;
+/**
+ * Request for batch file operations
+ */
+export declare const BatchOperationRequestSchema: z.ZodObject<{
+    /** List of operations to perform */
+    operations: z.ZodArray<z.ZodDiscriminatedUnion<"operation", [z.ZodObject<{
+        operation: z.ZodLiteral<"write">;
+        path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        content: z.ZodString;
+        overwrite: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        overwrite: boolean;
+        content: string;
+        operation: "write";
+    }, {
+        path: string;
+        content: string;
+        operation: "write";
+        overwrite?: boolean | undefined;
+    }>, z.ZodObject<{
+        operation: z.ZodLiteral<"mkdir">;
+        path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        recursive: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        recursive: boolean;
+        operation: "mkdir";
+    }, {
+        path: string;
+        operation: "mkdir";
+        recursive?: boolean | undefined;
+    }>]>, "many">;
+    /** Stop on first error */
+    stopOnError: z.ZodDefault<z.ZodBoolean>;
+    /** Dry run - validate without executing */
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    dryRun: boolean;
+    operations: ({
+        path: string;
+        overwrite: boolean;
+        content: string;
+        operation: "write";
+    } | {
+        path: string;
+        recursive: boolean;
+        operation: "mkdir";
+    })[];
+    stopOnError: boolean;
+}, {
+    operations: ({
+        path: string;
+        content: string;
+        operation: "write";
+        overwrite?: boolean | undefined;
+    } | {
+        path: string;
+        operation: "mkdir";
+        recursive?: boolean | undefined;
+    })[];
+    dryRun?: boolean | undefined;
+    stopOnError?: boolean | undefined;
+}>;
+export type BatchOperationRequest = z.infer<typeof BatchOperationRequestSchema>;
+/**
+ * Result of a single operation in a batch
+ */
+export declare const BatchOperationResultItemSchema: z.ZodObject<{
+    /** Operation index in the batch */
+    index: z.ZodNumber;
+    /** Path affected */
+    path: z.ZodString;
+    /** Whether operation succeeded */
+    success: z.ZodBoolean;
+    /** Operation type */
+    operation: z.ZodEnum<["write", "mkdir"]>;
+    /** Error if failed */
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+    }, {
+        code: string;
+        message: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    success: boolean;
+    operation: "write" | "mkdir";
+    index: number;
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+}, {
+    path: string;
+    success: boolean;
+    operation: "write" | "mkdir";
+    index: number;
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+}>;
+export type BatchOperationResultItem = z.infer<typeof BatchOperationResultItemSchema>;
+/**
+ * Result of batch operations
+ */
+export declare const BatchOperationResultSchema: z.ZodObject<{
+    /** Overall success */
+    success: z.ZodBoolean;
+    /** Total operations attempted */
+    total: z.ZodNumber;
+    /** Successful operations */
+    succeeded: z.ZodNumber;
+    /** Failed operations */
+    failed: z.ZodNumber;
+    /** Individual results */
+    results: z.ZodArray<z.ZodObject<{
+        /** Operation index in the batch */
+        index: z.ZodNumber;
+        /** Path affected */
+        path: z.ZodString;
+        /** Whether operation succeeded */
+        success: z.ZodBoolean;
+        /** Operation type */
+        operation: z.ZodEnum<["write", "mkdir"]>;
+        /** Error if failed */
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            code: string;
+            message: string;
+        }, {
+            code: string;
+            message: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        success: boolean;
+        operation: "write" | "mkdir";
+        index: number;
+        error?: {
+            code: string;
+            message: string;
+        } | undefined;
+    }, {
+        path: string;
+        success: boolean;
+        operation: "write" | "mkdir";
+        index: number;
+        error?: {
+            code: string;
+            message: string;
+        } | undefined;
+    }>, "many">;
+    /** Whether this was a dry run */
+    dryRun: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    failed: number;
+    success: boolean;
+    total: number;
+    results: {
+        path: string;
+        success: boolean;
+        operation: "write" | "mkdir";
+        index: number;
+        error?: {
+            code: string;
+            message: string;
+        } | undefined;
+    }[];
+    succeeded: number;
+    dryRun: boolean;
+}, {
+    failed: number;
+    success: boolean;
+    total: number;
+    results: {
+        path: string;
+        success: boolean;
+        operation: "write" | "mkdir";
+        index: number;
+        error?: {
+            code: string;
+            message: string;
+        } | undefined;
+    }[];
+    succeeded: number;
+    dryRun: boolean;
+}>;
+export type BatchOperationResult = z.infer<typeof BatchOperationResultSchema>;
+/**
+ * File system error codes
+ */
+export declare const FileSystemErrorCode: {
+    /** Path contains traversal attempt */
+    readonly PATH_TRAVERSAL: "PATH_TRAVERSAL";
+    /** File already exists (and overwrite=false) */
+    readonly FILE_EXISTS: "FILE_EXISTS";
+    /** Permission denied */
+    readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+    /** Invalid path format */
+    readonly INVALID_PATH: "INVALID_PATH";
+    /** Write operation failed */
+    readonly WRITE_FAILED: "WRITE_FAILED";
+    /** Directory creation failed */
+    readonly MKDIR_FAILED: "MKDIR_FAILED";
+    /** Path is outside workspace */
+    readonly OUTSIDE_WORKSPACE: "OUTSIDE_WORKSPACE";
+    /** Path is a symlink (not allowed) */
+    readonly SYMLINK_NOT_ALLOWED: "SYMLINK_NOT_ALLOWED";
+    /** Operation would affect too many files */
+    readonly BATCH_LIMIT_EXCEEDED: "BATCH_LIMIT_EXCEEDED";
+};
+export type FileSystemErrorCode = (typeof FileSystemErrorCode)[keyof typeof FileSystemErrorCode];
+export declare function validateFileWriteRequest(data: unknown): FileWriteRequest;
+export declare function validateDirectoryCreateRequest(data: unknown): DirectoryCreateRequest;
+export declare function validateBatchOperationRequest(data: unknown): BatchOperationRequest;
+/**
+ * Check if a path is safe (no traversal, within workspace)
+ */
+export declare function isPathSafe(filePath: string): boolean;
+/**
+ * file_write tool input schema
+ */
+export declare const FileWriteInputSchema: z.ZodObject<{
+    /** Relative path from workspace root */
+    path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    /** File content to write */
+    content: z.ZodString;
+    /** Create parent directories if they don't exist */
+    createDirectories: z.ZodDefault<z.ZodBoolean>;
+    /** Allow overwriting existing files */
+    overwrite: z.ZodDefault<z.ZodBoolean>;
+    /** File encoding */
+    encoding: z.ZodDefault<z.ZodEnum<["utf-8", "ascii", "base64", "binary"]>>;
+    /** Optional backup before overwrite */
+    backup: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    overwrite: boolean;
+    content: string;
+    createDirectories: boolean;
+    encoding: "base64" | "utf-8" | "ascii" | "binary";
+    backup: boolean;
+}, {
+    path: string;
+    content: string;
+    overwrite?: boolean | undefined;
+    createDirectories?: boolean | undefined;
+    encoding?: "base64" | "utf-8" | "ascii" | "binary" | undefined;
+    backup?: boolean | undefined;
+}>;
+/**
+ * file_write tool output schema
+ */
+export declare const FileWriteOutputSchema: z.ZodObject<{
+    /** Whether the operation succeeded */
+    success: z.ZodBoolean;
+    /** Path that was written */
+    path: z.ZodString;
+    /** Number of bytes written */
+    bytesWritten: z.ZodNumber;
+    /** Whether a new file was created */
+    created: z.ZodBoolean;
+    /** Whether an existing file was overwritten */
+    overwritten: z.ZodBoolean;
+    /** Backup path if backup was created */
+    backupPath: z.ZodOptional<z.ZodString>;
+    /** Error details if operation failed */
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+    }, {
+        code: string;
+        message: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    success: boolean;
+    created: boolean;
+    bytesWritten: number;
+    overwritten: boolean;
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+    backupPath?: string | undefined;
+}, {
+    path: string;
+    success: boolean;
+    created: boolean;
+    bytesWritten: number;
+    overwritten: boolean;
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+    backupPath?: string | undefined;
+}>;
+/**
+ * directory_create tool input schema
+ */
+export declare const DirectoryCreateInputSchema: z.ZodObject<{
+    /** Relative path from workspace root */
+    path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    /** Create parent directories if they don't exist */
+    recursive: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    recursive: boolean;
+}, {
+    path: string;
+    recursive?: boolean | undefined;
+}>;
+/**
+ * directory_create tool output schema
+ */
+export declare const DirectoryCreateOutputSchema: z.ZodObject<{
+    /** Whether the operation succeeded */
+    success: z.ZodBoolean;
+    /** Path that was created */
+    path: z.ZodString;
+    /** Whether a new directory was created */
+    created: z.ZodBoolean;
+    /** Whether the directory already existed */
+    existed: z.ZodBoolean;
+    /** Error details if operation failed */
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+    }, {
+        code: string;
+        message: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    success: boolean;
+    created: boolean;
+    existed: boolean;
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+}, {
+    path: string;
+    success: boolean;
+    created: boolean;
+    existed: boolean;
+    error?: {
+        code: string;
+        message: string;
+    } | undefined;
+}>;
+/**
+ * file_exists tool input schema
+ */
+export declare const FileExistsInputSchema: z.ZodObject<{
+    /** Relative path from workspace root */
+    path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+/**
+ * file_exists tool output schema
+ */
+export declare const FileExistsOutputSchema: z.ZodObject<{
+    /** Path that was checked */
+    path: z.ZodString;
+    /** Whether the file exists */
+    exists: z.ZodBoolean;
+    /** Whether it's a file (vs directory) */
+    isFile: z.ZodOptional<z.ZodBoolean>;
+    /** Whether it's a directory */
+    isDirectory: z.ZodOptional<z.ZodBoolean>;
+    /** File size in bytes (if exists and is file) */
+    size: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    exists: boolean;
+    isFile?: boolean | undefined;
+    isDirectory?: boolean | undefined;
+    size?: number | undefined;
+}, {
+    path: string;
+    exists: boolean;
+    isFile?: boolean | undefined;
+    isDirectory?: boolean | undefined;
+    size?: number | undefined;
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/file-system/v1/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/file-system/v1/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;;;;GAKG;AACH,eAAO,MAAM,cAAc,yEAWxB,CAAC;AAEJ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAMtD;;GAEG;AACH,eAAO,MAAM,kBAAkB,mDAAiD,CAAC;AAEjF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;IACjC,wCAAwC;;IAGxC,4BAA4B;;IAG5B,oDAAoD;;IAGpD,uCAAuC;;IAGvC,oBAAoB;;IAGpB,uCAAuC;;;;;;;;;;;;;;;;EAEvC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,qBAAqB;IAChC,sCAAsC;;IAGtC,4BAA4B;;IAG5B,8BAA8B;;IAG9B,qCAAqC;;IAGrC,+CAA+C;;IAG/C,wCAAwC;;IAGxC,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOxC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAMpE;;GAEG;AACH,eAAO,MAAM,4BAA4B;IACvC,wCAAwC;;IAGxC,oDAAoD;;;;;;;;EAEpD,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,2BAA2B;IACtC,sCAAsC;;IAGtC,4BAA4B;;IAG5B,0CAA0C;;IAG1C,4CAA4C;;IAG5C,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOxC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAMhF;;GAEG;AACH,eAAO,MAAM,uBAAuB;IAClC,wCAAwC;;;;;;EAExC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,sBAAsB;IACjC,4BAA4B;;IAG5B,8BAA8B;;IAG9B,yCAAyC;;IAGzC,+BAA+B;;IAG/B,iDAAiD;;;;;;;;;;;;;;EAEjD,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAMtE;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;GAEG;AACH,eAAO,MAAM,2BAA2B;IACtC,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGpC,0BAA0B;;IAG1B,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3C,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF;;GAEG;AACH,eAAO,MAAM,8BAA8B;IACzC,mCAAmC;;IAGnC,oBAAoB;;IAGpB,kCAAkC;;IAGlC,qBAAqB;;IAGrB,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOtB,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF;;GAEG;AACH,eAAO,MAAM,0BAA0B;IACrC,sBAAsB;;IAGtB,iCAAiC;;IAGjC,4BAA4B;;IAG5B,wBAAwB;;IAGxB,yBAAyB;;QAvCzB,mCAAmC;;QAGnC,oBAAoB;;QAGpB,kCAAkC;;QAGlC,qBAAqB;;QAGrB,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8BtB,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEjC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAM9E;;GAEG;AACH,eAAO,MAAM,mBAAmB;IAC9B,sCAAsC;;IAGtC,gDAAgD;;IAGhD,wBAAwB;;IAGxB,0BAA0B;;IAG1B,6BAA6B;;IAG7B,gCAAgC;;IAGhC,gCAAgC;;IAGhC,sCAAsC;;IAGtC,4CAA4C;;CAEpC,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC;AAMjG,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CAExE;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,OAAO,GAAG,sBAAsB,CAEpF;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,OAAO,GAAG,qBAAqB,CAElF;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAOpD;AAMD;;GAEG;AACH,eAAO,MAAM,oBAAoB;IA1S/B,wCAAwC;;IAGxC,4BAA4B;;IAG5B,oDAAoD;;IAGpD,uCAAuC;;IAGvC,oBAAoB;;IAGpB,uCAAuC;;;;;;;;;;;;;;;;EA2RiB,CAAC;AAE3D;;GAEG;AACH,eAAO,MAAM,qBAAqB;IAtRhC,sCAAsC;;IAGtC,4BAA4B;;IAG5B,8BAA8B;;IAG9B,qCAAqC;;IAGrC,+CAA+C;;IAG/C,wCAAwC;;IAGxC,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoQgB,CAAC;AAE3D;;GAEG;AACH,eAAO,MAAM,0BAA0B;IAtPrC,wCAAwC;;IAGxC,oDAAoD;;;;;;;;EAmPgB,CAAC;AAEvE;;GAEG;AACH,eAAO,MAAM,2BAA2B;IA9OtC,sCAAsC;;IAGtC,4BAA4B;;IAG5B,0CAA0C;;IAG1C,4CAA4C;;IAG5C,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkO4B,CAAC;AAEvE;;GAEG;AACH,eAAO,MAAM,qBAAqB;IApNhC,wCAAwC;;;;;;EAoNkB,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,sBAAsB;IA/MjC,4BAA4B;;IAG5B,8BAA8B;;IAG9B,yCAAyC;;IAGzC,+BAA+B;;IAG/B,iDAAiD;;;;;;;;;;;;;;EAmMS,CAAC"}