import { z } from 'zod';
import * as Cast from './cast.js';
import { MAKE, TEST } from '@termsurf/form';
import * as code from './source/index.js';
export const AssemblySyntaxModel = z.enum(Cast.ASSEMBLY_SYNTAX);
export const BackendCompilationOutputModel = z.enum(Cast.BACKEND_COMPILATION_OUTPUT);
export const BuildCommandToWriteMetadataToImageModel = z.object({
    inputPath: z.string(),
    copyright: z.optional(z.string()),
    creator: z.optional(z.string()),
    license: z.optional(z.string()),
});
export const BuildBaseFileInputModel = z
    .object({
    tool: z.optional(z.string()),
    input: z
        .object({
        file: z
            .object({
            path: z.string(),
        })
            .passthrough(),
    })
        .passthrough(),
    output: z
        .object({
        file: z
            .object({
            path: z.string(),
        })
            .passthrough(),
    })
        .passthrough(),
})
    .passthrough();
export const BuildBaseFileInputOutputModel = z
    .object({
    tool: z.optional(z.string()),
    input: z
        .object({
        file: z
            .object({
            path: z.string(),
        })
            .passthrough(),
    })
        .passthrough(),
    output: z
        .object({
        file: z
            .object({
            path: z.optional(z.string()),
        })
            .passthrough(),
        format: z.optional(z.string()),
    })
        .passthrough(),
})
    .passthrough();
export const BuildBaseInputDirectoryOrFileOutputFileModel = z
    .object({
    input: z
        .object({
        directory: z.optional(z
            .object({
            path: z.string(),
        })
            .passthrough()),
        file: z.optional(z
            .object({
            path: z.string(),
        })
            .passthrough()),
    })
        .passthrough(),
    output: z
        .object({
        file: z
            .object({
            path: z.string(),
        })
            .passthrough(),
    })
        .passthrough(),
})
    .passthrough();
export const BuildBaseInputFileOutputDirectoryModel = z
    .object({
    output: z
        .object({
        directory: z
            .object({
            path: z.string(),
        })
            .passthrough(),
    })
        .passthrough(),
    input: z
        .object({
        file: z
            .object({
            path: z.string(),
        })
            .passthrough(),
    })
        .passthrough(),
})
    .passthrough();
export const BuildCommandToAddAudioToVideoWithFfmpegModel = z.object({
    inputVideoPath: z.string(),
    inputAudioPath: z.string(),
    outputPath: z.string(),
    audioCodec: z.string(),
    fit: z.boolean(),
});
export const BuildCommandToCompileCModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    optimizationLevel: z.optional(z.lazy(() => LlvmOptimizationLevelModel).default('0')),
    fastMath: z.optional(z.boolean()).default(false),
    format: z.lazy(() => BackendCompilationOutputModel),
    syntax: z.optional(z.lazy(() => AssemblySyntaxModel)),
});
export const BuildCommandToCompileCppModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    optimizationLevel: z.optional(z.lazy(() => LlvmOptimizationLevelModel).default('0')),
    fastMath: z.optional(z.boolean()).default(false),
    format: z.lazy(() => BackendCompilationOutputModel),
    syntax: z.optional(z.lazy(() => AssemblySyntaxModel)),
});
export const BuildCommandToCompileSwiftModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    format: z.lazy(() => BackendCompilationOutputModel),
});
export const BuildCommandToCompressMp4WithFfmpegModel = z.object({
    inputPath: z.string(),
    outputPath: z.string(),
    audioCodec: z.optional(z.lazy(() => FfmpegCodecAudioModel).default('aac')),
    videoCodec: z.optional(z.lazy(() => FfmpegCodecVideoModel).default('h264')),
});
export const BuildCommandToCompressWithZipModel = z.object({
    input: z.object({
        directory: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToConvertAiToSvgWithInkscapeModel = z.object({
    input: z.object({
        file: z.object({
            path: z.optional(z.string()),
            buffer: z.optional(z.instanceof(ArrayBuffer)),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
            format: z.string(),
        }),
    }),
});
export const BuildCommandToConvertArchiveModel = z.object({
    temporary: z.object({
        directory: z.object({
            path: z.string(),
        }),
    }),
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToConvertDocumentWithCalibreModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
            format: z.optional(z.string()),
        }),
    }),
});
export const BuildCommandToConvertDocumentWithJupyterModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            format: z.string(),
        }),
        format: z.string(),
    }),
});
export const BuildCommandToConvertDocumentWithLibreOfficeModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            format: z.string(),
        }),
        directory: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToConvertDocumentWithPandocModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
        format: z.optional(z.lazy(() => PandocOutputFormatModel)),
    }),
});
export const BuildCommandToConvertFontWithFontForgeModel = z
    .object({
    input: z.object({
        file: z.object({
            path: z.optional(z.string()),
            buffer: z.optional(z.instanceof(ArrayBuffer)),
            format: z.optional(z.string()),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.optional(z.string()),
            format: z.optional(z.string()),
        }),
    }),
})
    .transform(MAKE('build_command_to_convert_font_with_font_forge', code.transform_input_output_file.make));
export const BuildCommandToConvertMp4ToGifWithFfmpegModel = z.object({
    inputPath: z.string(),
    outputPath: z.string(),
    fps: z.number().int(),
    width: z.number().int(),
    startTime: z.union([
        z
            .number()
            .int()
            .refine(TEST('startTime', code.test_time_integer.test)),
        z.string().refine(TEST('startTime', code.test_time_string.test)),
    ]),
    endTime: z.union([
        z
            .number()
            .int()
            .refine(TEST('endTime', code.test_time_integer.test)),
        z.string().refine(TEST('endTime', code.test_time_string.test)),
    ]),
    duration: z.union([
        z
            .number()
            .int()
            .refine(TEST('duration', code.test_time_integer.test)),
        z.string().refine(TEST('duration', code.test_time_string.test)),
    ]),
});
export const BuildCommandToConvertVideoToAudioWithFfmpegModel = z.object({
    inputPath: z.string(),
    outputPath: z.string(),
});
export const BuildCommandToConvertVideoWithFfmpegModel = z.object({
    inputPath: z.optional(z.string()),
    outputPath: z.optional(z.string()),
    inputExtension: z.optional(z.string()),
    outputExtension: z.optional(z.string()),
    input: z.optional(z.instanceof(ArrayBuffer)),
    output: z.optional(z.instanceof(ArrayBuffer)),
    audioCodec: z.optional(z.lazy(() => FfmpegCodecAudioModel)),
    videoCodec: z.optional(z.lazy(() => FfmpegCodecVideoModel)),
    audioBitRate: z.optional(z.number().int()),
    videoBitRate: z.optional(z.number().int()),
    frameRate: z.optional(z.number().int()),
    startTime: z.optional(z.union([
        z
            .number()
            .int()
            .refine(TEST('startTime', code.test_time_integer.test)),
        z
            .string()
            .refine(TEST('startTime', code.test_time_string.test)),
    ])),
    endTime: z.optional(z.union([
        z
            .number()
            .int()
            .refine(TEST('endTime', code.test_time_integer.test)),
        z.string().refine(TEST('endTime', code.test_time_string.test)),
    ])),
    strict: z.optional(z.lazy(() => FfmpegStrictOptionModel).default('strict')),
    overwrite: z.optional(z.boolean()).default(false),
    progress: z.optional(z.boolean()).default(false),
    scaleWidth: z.optional(z.number().int()),
    scaleHeight: z.optional(z.number().int()),
    audioChannels: z.optional(z.number().int()),
    audioSamplingFrequency: z.optional(z.number().int()),
    subtitleCodec: z.optional(z.lazy(() => FfmpegCodecSubtitleModel)),
    duration: z.optional(z.union([
        z
            .number()
            .int()
            .refine(TEST('duration', code.test_time_integer.test)),
        z.string().refine(TEST('duration', code.test_time_string.test)),
    ])),
    rotation: z.optional(z.number()),
});
export const BuildCommandToConvertVideoWithFfmpegBaseModel = z.object({
    audioCodec: z.optional(z.lazy(() => FfmpegCodecAudioModel)),
    videoCodec: z.optional(z.lazy(() => FfmpegCodecVideoModel)),
    audioBitRate: z.optional(z.number().int()),
    videoBitRate: z.optional(z.number().int()),
    frameRate: z.optional(z.number().int()),
    startTime: z.optional(z.union([
        z
            .number()
            .int()
            .refine(TEST('startTime', code.test_time_integer.test)),
        z
            .string()
            .refine(TEST('startTime', code.test_time_string.test)),
    ])),
    endTime: z.optional(z.union([
        z
            .number()
            .int()
            .refine(TEST('endTime', code.test_time_integer.test)),
        z.string().refine(TEST('endTime', code.test_time_string.test)),
    ])),
    strict: z.optional(z.lazy(() => FfmpegStrictOptionModel).default('strict')),
    overwrite: z.optional(z.boolean()).default(false),
    progress: z.optional(z.boolean()).default(false),
    scaleWidth: z.optional(z.number().int()),
    scaleHeight: z.optional(z.number().int()),
    audioChannels: z.optional(z.number().int()),
    audioSamplingFrequency: z.optional(z.number().int()),
    subtitleCodec: z.optional(z.lazy(() => FfmpegCodecSubtitleModel)),
    duration: z.optional(z.union([
        z
            .number()
            .int()
            .refine(TEST('duration', code.test_time_integer.test)),
        z.string().refine(TEST('duration', code.test_time_string.test)),
    ])),
    rotation: z.optional(z.number()),
});
export const BuildCommandToCreateRarModel = z.object({
    input: z.object({
        directory: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToDecompress7ZModel = z.object({
    input: z.object({
        directory: z.optional(z.object({
            path: z.string(),
        })),
        file: z.optional(z.object({
            path: z.string(),
        })),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToDecompressWithUnarchiverModel = z.object({
    overwrite: z.optional(z.boolean()).default(false),
    password: z.optional(z.string()),
    output: z.object({
        directory: z.object({
            path: z.string(),
        }),
    }),
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToExtractMetadataFromImageModel = z.object({
    inputPath: z.string(),
    copyright: z.optional(z.string()),
    creator: z.optional(z.string()),
    license: z.optional(z.string()),
    keywords: z.optional(z.array(z.string())),
    artist: z.optional(z.string()),
    originalDate: z.optional(z.coerce.date()),
    allDates: z.optional(z.coerce.date()),
    creationDate: z.optional(z.coerce.date()),
    title: z.optional(z.string()),
    description: z.optional(z.string()),
});
export const BuildCommandToFormatAssemblyModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToFormatCModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToFormatCodeWithClangModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    style: z.optional(z.lazy(() => ClangStyleAllModel)),
});
export const BuildCommandToFormatCppModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToFormatJavaModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToFormatKotlinModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToFormatPythonModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToFormatRubyModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToFormatRustModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToFormatSwiftModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const BuildCommandToGenerateGifWithGifsicleModel = z.object({
    width: z.optional(z.number().int().gte(0)),
    height: z.optional(z.number().int().gte(0)),
    unoptimize: z.optional(z.boolean()),
});
export const BuildCommandToGenerateLatexPdfModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    output: z.object({
        directory: z.string(),
        file: z.object({
            name: z.string(),
        }),
    }),
});
export const BuildCommandToProcessImageModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
            format: z.string(),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
            format: z.optional(z.string()),
        }),
    }),
    colorCount: z.optional(z.number().int().gte(0)),
    colorMatrix: z.optional(z
        .lazy(() => ImageMagicColorMatrixModel)
        .refine(TEST('colorMatrix', code.test_image_magic_color_matrix.test))),
    colorSpace: z.optional(z.lazy(() => ImageMagickColorSpaceModel)),
    compare: z.optional(z.boolean()),
    compression: z.optional(z.lazy(() => ImageMagickCompressionModel)),
});
export const BuildCommandToRemoveAudioFromVideoWithFfmpegModel = z.object({
    inputPath: z.string(),
    outputPath: z.string(),
});
export const BuildCommandToReplaceImageColorWithImageMagickModel = z.object({
    inputPath: z.string(),
    outputPath: z.string(),
    startColor: z.string(),
    endColor: z.string(),
    fuzz: z.number(),
});
export const BuildCommandToResizeImageWithImageMagickModel = z.object({
    inputPath: z.string(),
    outputPath: z.string(),
    width: z.number().int(),
    height: z.number().int(),
    stretch: z.boolean(),
    gravity: z.lazy(() => ImageMagickGravityModel),
});
export const CalibreInputFormatContentKeyModel = z.enum(Cast.CALIBRE_INPUT_FORMAT_CONTENT_KEY);
export const CalibreInputProfileModel = z.enum(Cast.CALIBRE_INPUT_PROFILE);
export const CalibreOutputFormatContentKeyModel = z.enum(Cast.CALIBRE_OUTPUT_FORMAT_CONTENT_KEY);
export const CalibreOutputProfileModel = z.enum(Cast.CALIBRE_OUTPUT_PROFILE);
export const CheckIfPdfIsValidModel = z.object({
    input: z.object({
        file: z.object({
            buffer: z.instanceof(ArrayBuffer),
        }),
    }),
});
export const ClangStyleAllModel = z.object({
    basedOnStyle: z.optional(z.string()),
    alignAfterOpenBracket: z.optional(z.enum(['align', 'dontAlign', 'alwaysBreak', 'blockIndent'])),
    alignArrayOfStructures: z.optional(z.enum(['left', 'right', 'none'])),
    alignConsecutiveAssignments: z.optional(z.object({
        enabled: z.boolean(),
        acrossEmptyLines: z.boolean(),
        acrossComments: z.boolean(),
        alignCompound: z.boolean(),
        alignFunctionPointers: z.boolean(),
        padOperators: z.boolean(),
    })),
    alignConsecutiveBitFields: z.optional(z.object({
        enabled: z.boolean(),
        acrossEmptyLines: z.boolean(),
        acrossComments: z.boolean(),
        alignCompound: z.boolean(),
        alignFunctionPointers: z.boolean(),
        padOperators: z.boolean(),
    })),
    alignConsecutiveDeclarations: z.optional(z.object({
        enabled: z.boolean(),
        acrossEmptyLines: z.boolean(),
        acrossComments: z.boolean(),
        alignCompound: z.boolean(),
        alignFunctionPointers: z.boolean(),
        padOperators: z.boolean(),
    })),
    alignConsecutiveMacros: z.optional(z.object({
        enabled: z.boolean(),
        acrossEmptyLines: z.boolean(),
        acrossComments: z.boolean(),
        alignCompound: z.boolean(),
        alignFunctionPointers: z.boolean(),
        padOperators: z.boolean(),
    })),
    alignConsecutiveShortCaseStatements: z.optional(z.object({
        enabled: z.boolean(),
        acrossEmptyLines: z.boolean(),
        acrossComments: z.boolean(),
        alignCaseColons: z.boolean(),
    })),
    alignEscapedNewlines: z.optional(z.enum(['dontAlign', 'left', 'right'])),
    alignOperands: z.optional(z.enum(['dontAlign', 'align', 'alignAfterOperator'])),
    alignTrailingComments: z.optional(z.object({
        kind: z.object({}),
        overEmptyLines: z.number().int(),
    })),
    allowAllArgumentsOnNextLine: z.optional(z.boolean()),
    allowAllConstructorInitializersOnNextLine: z.optional(z.boolean()),
    allowAllParametersOfDeclarationOnNextLine: z.optional(z.boolean()),
    allowBreakBeforeNoexceptSpecifier: z.optional(z.enum(['never', 'onlyWithParen', 'always'])),
    allowShortBlocksOnASingleLine: z.optional(z.enum(['never', 'empty', 'always'])),
    allowShortCaseLabelsOnASingleLine: z.optional(z.boolean()),
    allowShortCompoundRequirementOnASingleLine: z.optional(z.boolean()),
    allowShortEnumsOnASingleLine: z.optional(z.boolean()),
    allowShortFunctionsOnASingleLine: z.optional(z.enum(['none', 'inlineOnly', 'empty', 'inline', 'all'])),
    allowShortIfStatementsOnASingleLine: z.optional(z.enum(['never', 'withoutElse', 'onlyFirstIf', 'allIfsAndElse'])),
    allowShortLambdasOnASingleLine: z.optional(z.enum(['none', 'empty', 'inline', 'all'])),
    allowShortLoopsOnASingleLine: z.optional(z.boolean()),
    alwaysBreakAfterDefinitionReturnType: z.optional(z.enum(['none', 'all', 'topLevel'])),
    alwaysBreakAfterReturnType: z.optional(z.enum([
        'none',
        'all',
        'topLevel',
        'allDefinitions',
        'topLevelDefinitions',
    ])),
    alwaysBreakBeforeMultilineStrings: z.optional(z.boolean()),
    alwaysBreakTemplateDeclarations: z.optional(z.enum(['no', 'multiLine', 'yes'])),
    attributeMacros: z.optional(z.array(z.string())),
    binPackArguments: z.optional(z.boolean()),
    binPackParameters: z.optional(z.boolean()),
    bitFieldColonSpacing: z.optional(z.enum(['both', 'none', 'before', 'after'])),
    braceWrapping: z.optional(z.object({
        afterCaseLabel: z.boolean(),
        afterClass: z.boolean(),
        afterControlStatement: z.object({}),
        afterEnum: z.boolean(),
        afterFunction: z.boolean(),
        afterNamespace: z.boolean(),
        afterObjCDeclaration: z.boolean(),
        afterStruct: z.boolean(),
        afterUnion: z.boolean(),
        afterExternBlock: z.boolean(),
        beforeCatch: z.boolean(),
        beforeElse: z.boolean(),
        beforeLambdaBody: z.boolean(),
        beforeWhile: z.boolean(),
        indentBraces: z.boolean(),
        splitEmptyFunction: z.boolean(),
        splitEmptyRecord: z.boolean(),
        splitEmptyNamespace: z.boolean(),
    })),
    bracedInitializerIndentWidth: z.optional(z.number().int()),
    breakAdjacentStringLiterals: z.optional(z.boolean()),
    breakAfterAttributes: z.optional(z.enum(['always', 'leave', 'never'])),
    breakArrays: z.optional(z.boolean()),
    breakBeforeBinaryOperators: z.optional(z.enum(['none', 'nonAssignment', 'all'])),
    breakBeforeBraces: z.optional(z.enum([
        'attach',
        'linux',
        'mozilla',
        'stroustrup',
        'allman',
        'whitesmiths',
        'gnu',
        'webKit',
        'custom',
    ])),
    breakBeforeConceptDeclarations: z.optional(z.enum(['never', 'allowed', 'always'])),
    breakBeforeInlineAsmColon: z.optional(z.enum(['never', 'onlyMultiline', 'always'])),
    breakBeforeTernaryOperators: z.optional(z.boolean()),
    breakConstructorInitializers: z.optional(z.enum(['beforeColon', 'beforeComma', 'afterColon'])),
    breakInheritanceList: z.optional(z.enum([
        'beforeColon',
        'beforeComma',
        'afterColon',
        'afterComma',
    ])),
    breakStringLiterals: z.optional(z.boolean()),
    columnLimit: z.optional(z.number().int()),
    commentPragmas: z.optional(z.string()),
    compactNamespaces: z.optional(z.boolean()),
    constructorInitializerAllOnOneLineOrOnePerLine: z.optional(z.boolean()),
    constructorInitializerIndentWidth: z.optional(z.number().int()),
    continuationIndentWidth: z.optional(z.number().int()),
    deriveLineEnding: z.optional(z.boolean()),
    derivePointerAlignment: z.optional(z.boolean()),
    disableFormat: z.optional(z.boolean()),
    emptyLineAfterAccessModifier: z.optional(z.enum(['never', 'leave', 'always'])),
    emptyLineBeforeAccessModifier: z.optional(z.enum(['never', 'leave', 'logicalBlock', 'always'])),
    experimentalAutoDetectBinPacking: z.optional(z.boolean()),
    fixNamespaceComments: z.optional(z.boolean()),
    forEachMacros: z.optional(z.array(z.string())),
    ifMacros: z.optional(z.array(z.string())),
    includeBlocks: z.optional(z.enum(['preserve', 'merge', 'regroup'])),
    includeIsMainRegex: z.optional(z.string()),
    includeIsMainSourceRegex: z.optional(z.string()),
    indentAccessModifiers: z.optional(z.boolean()),
    indentCaseBlocks: z.optional(z.boolean()),
    indentCaseLabels: z.optional(z.boolean()),
    indentExternBlock: z.optional(z.enum(['afterExternBlock', 'noIndent', 'indent'])),
    indentGotoLabels: z.optional(z.boolean()),
    indentPpDirectives: z.optional(z.enum(['none', 'afterHash', 'beforeHash'])),
    indentRequiresClause: z.optional(z.boolean()),
    indentWidth: z.optional(z.number().int()),
    indentWrappedFunctionNames: z.optional(z.boolean()),
    insertBraces: z.optional(z.boolean()),
    insertNewlineAtEof: z.optional(z.boolean()),
    insertTrailingCommas: z.optional(z.enum(['none', 'wrapped'])),
    integerLiteralSeparator: z.optional(z.object({})),
    keepEmptyLinesAtEof: z.optional(z.boolean()),
    keepEmptyLinesAtTheStartOfBlocks: z.optional(z.boolean()),
    lambdaBodyIndentation: z.optional(z.enum(['signature', 'outerScope'])),
    language: z.optional(z.enum([
        'none',
        'cpp',
        'cSharp',
        'java',
        'javaScript',
        'json',
        'objC',
        'proto',
        'tableGen',
        'textProto',
        'verilog',
    ])),
    lineEnding: z.optional(z.enum(['lf', 'crlf', 'deriveLf', 'deriveCrlf'])),
    macroBlockBegin: z.optional(z.string()),
    macroBlockEnd: z.optional(z.string()),
    macros: z.optional(z.array(z.string())),
    maxEmptyLinesToKeep: z.optional(z.number().int()),
    namespaceIndentation: z.optional(z.enum(['none', 'inner', 'all'])),
    namespaceMacros: z.optional(z.array(z.string())),
    packConstructorInitializers: z.optional(z.enum([
        'never',
        'binPack',
        'currentLine',
        'nextLine',
        'nextLineOnly',
    ])),
    penaltyBreakAssignment: z.optional(z.number().int()),
    penaltyBreakBeforeFirstCallParameter: z.optional(z.number().int()),
    penaltyBreakComment: z.optional(z.number().int()),
    penaltyBreakFirstLessLess: z.optional(z.number().int()),
    penaltyBreakOpenParenthesis: z.optional(z.number().int()),
    penaltyBreakString: z.optional(z.number().int()),
    penaltyBreakTemplateDeclaration: z.optional(z.number().int()),
    penaltyExcessCharacter: z.optional(z.number().int()),
    penaltyIndentedWhitespace: z.optional(z.number().int()),
    penaltyReturnTypeOnItsOwnLine: z.optional(z.number().int()),
    pointerAlignment: z.optional(z.enum(['left', 'right', 'middle'])),
    qualifierAlignment: z.optional(z.enum(['leave', 'left', 'right', 'custom'])),
    qualifierOrder: z.optional(z.array(z.string())),
    referenceAlignment: z.optional(z.enum(['pointer', 'left', 'right', 'middle'])),
    reflowComments: z.optional(z.boolean()),
    removeBracesLlvm: z.optional(z.boolean()),
    removeParentheses: z.optional(z.enum(['leave', 'multipleParentheses', 'returnStatement'])),
    removeSemicolon: z.optional(z.boolean()),
    requiresClausePosition: z.optional(z.enum([
        'ownLine',
        'withPreceding',
        'withFollowing',
        'singleLine',
    ])),
    requiresExpressionIndentation: z.optional(z.enum(['outerScope', 'keyword'])),
    separateDefinitionBlocks: z.optional(z.enum(['leave', 'always', 'never'])),
    shortNamespaceLines: z.optional(z.number().int()),
    sortIncludes: z.optional(z.enum(['never', 'caseSensitive', 'caseInsensitive'])),
    sortUsingDeclarations: z.optional(z.enum(['never', 'lexicographic', 'lexicographicNumeric'])),
    spaceAfterCStyleCast: z.optional(z.boolean()),
    spaceAfterLogicalNot: z.optional(z.boolean()),
    spaceAfterTemplateKeyword: z.optional(z.boolean()),
    spaceAroundPointerQualifiers: z.optional(z.enum(['default', 'before', 'after', 'both'])),
    spaceBeforeAssignmentOperators: z.optional(z.boolean()),
    spaceBeforeCaseColon: z.optional(z.boolean()),
    spaceBeforeCtorInitializerColon: z.optional(z.boolean()),
    spaceBeforeInheritanceColon: z.optional(z.boolean()),
    spaceBeforeJsonColon: z.optional(z.boolean()),
    spaceBeforeParens: z.optional(z.enum([
        'never',
        'controlStatements',
        'controlStatementsExceptControlMacros',
        'nonEmptyParentheses',
        'always',
        'custom',
    ])),
    spaceBeforeParensOptions: z.optional(z.object({
        afterControlStatements: z.boolean(),
        afterForeachMacros: z.boolean(),
        afterFunctionDeclarationName: z.boolean(),
        afterFunctionDefinitionName: z.boolean(),
        afterIfMacros: z.boolean(),
        afterOverloadedOperator: z.boolean(),
        afterPlacementOperator: z.object({}),
        afterRequiresInClause: z.boolean(),
        afterRequiresInExpression: z.boolean(),
        beforeNonEmptyParentheses: z.boolean(),
    })),
    spaceBeforeRangeBasedForLoopColon: z.optional(z.boolean()),
    spaceBeforeSquareBrackets: z.optional(z.boolean()),
    spaceInEmptyBlock: z.optional(z.boolean()),
    spaceInEmptyParentheses: z.optional(z.boolean()),
    spacesBeforeTrailingComments: z.optional(z.number().int()),
    spacesInAngles: z.optional(z.enum(['never', 'always', 'leave'])),
    spacesInCStyleCastParentheses: z.optional(z.boolean()),
    spacesInConditionalStatement: z.optional(z.boolean()),
    spacesInContainerLiterals: z.optional(z.boolean()),
    spacesInLineCommentPrefix: z.optional(z.object({
        minimum: z.number().int(),
        maximum: z.number().int(),
    })),
    spacesInParens: z.optional(z.enum(['never', 'custom'])),
    spacesInParensOptions: z.optional(z.object({
        inConditionalStatements: z.boolean(),
        inCStyleCasts: z.boolean(),
        inEmptyParentheses: z.boolean(),
        other: z.boolean(),
    })),
    spacesInParentheses: z.optional(z.boolean()),
    spacesInSquareBrackets: z.optional(z.boolean()),
    standard: z.optional(z.enum([
        'lsCpp03',
        'lsCpp11',
        'lsCpp14',
        'lsCpp17',
        'lsCpp20',
        'latest',
        'auto',
    ])),
    statementAttributeLikeMacros: z.optional(z.array(z.string())),
    statementMacros: z.optional(z.array(z.string())),
    tabWidth: z.optional(z.number().int()),
    typeNames: z.optional(z.array(z.string())),
    typenameMacros: z.optional(z.array(z.string())),
    useCrlf: z.optional(z.boolean()),
    useTab: z.optional(z.enum([
        'never',
        'forIndentation',
        'forContinuationAndIndentation',
        'alignWithSpaces',
        'always',
    ])),
    verilogBreakBetweenInstancePorts: z.optional(z.boolean()),
    whitespaceSensitiveMacros: z.optional(z.array(z.string())),
});
export const ClangStyleCppModel = ClangStyleAllModel.extend({
    cpp11BracedListStyle: z.optional(z.boolean()),
    spaceBeforeCpp11BracedList: z.optional(z.boolean()),
});
export const ClangStyleJavaModel = ClangStyleAllModel.extend({
    breakAfterJavaFieldAnnotations: z.optional(z.boolean()),
    javaImportGroups: z.optional(z.array(z.string())),
    sortJavaStaticImport: z.optional(z.enum(['before', 'after'])),
});
export const ClangStyleJavascriptModel = ClangStyleAllModel.extend({
    javaScriptQuotes: z.optional(z.enum(['leave', 'single', 'double'])),
    javaScriptWrapImports: z.optional(z.boolean()),
});
export const ClangStyleObjcModel = ClangStyleAllModel.extend({
    objCBinPackProtocolList: z.optional(z.enum(['auto', 'always', 'never'])),
    objCBlockIndentWidth: z.optional(z.number().int()),
    objCBreakBeforeNestedBlockParam: z.optional(z.boolean()),
    objCPropertyAttributeOrder: z.optional(z.array(z.string())),
    objCSpaceAfterProperty: z.optional(z.boolean()),
    objCSpaceBeforeProtocolList: z.optional(z.boolean()),
});
export const ConvertHtmlToPdfModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
            buffer: z.optional(z.instanceof(ArrayBuffer)),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    viewport: z.object({
        width: z.optional(z.number().int().gte(0)),
        height: z.optional(z.number().int().gte(0)),
    }),
    proxy: z.optional(z.string()),
    waitUntil: z.optional(z.lazy(() => PuppeteerLifeCycleEventModel)),
});
export const ConvertHtmlToPngModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
            buffer: z.optional(z.instanceof(ArrayBuffer)),
        }),
    }),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    viewport: z.object({
        width: z.optional(z.number().int().gte(0)),
        height: z.optional(z.number().int().gte(0)),
    }),
    proxy: z.optional(z.string()),
    waitUntil: z.optional(z.lazy(() => PuppeteerLifeCycleEventModel)),
});
export const ExiftoolFamilyContentKeyModel = z.enum(Cast.EXIFTOOL_FAMILY_CONTENT_KEY);
export const ExiftoolImageFormatContentKeyModel = z.enum(Cast.EXIFTOOL_IMAGE_FORMAT_CONTENT_KEY);
export const ExiftoolTagContentKeyModel = z.enum(Cast.EXIFTOOL_TAG_CONTENT_KEY);
export const FfmpegCodecAudioModel = z.enum(Cast.FFMPEG_CODEC_AUDIO);
export const FfmpegCodecContentKeyModel = z.enum(Cast.FFMPEG_CODEC_CONTENT_KEY);
export const FfmpegCodecSubtitleModel = z.enum(Cast.FFMPEG_CODEC_SUBTITLE);
export const FfmpegCodecVideoModel = z.enum(Cast.FFMPEG_CODEC_VIDEO);
export const FfmpegDecoderAudioModel = z.enum(Cast.FFMPEG_DECODER_AUDIO);
export const FfmpegDecoderContentKeyModel = z.enum(Cast.FFMPEG_DECODER_CONTENT_KEY);
export const FfmpegDecoderSubtitleModel = z.enum(Cast.FFMPEG_DECODER_SUBTITLE);
export const FfmpegDecoderVideoModel = z.enum(Cast.FFMPEG_DECODER_VIDEO);
export const FfmpegEncoderAudioModel = z.enum(Cast.FFMPEG_ENCODER_AUDIO);
export const FfmpegEncoderContentKeyModel = z.enum(Cast.FFMPEG_ENCODER_CONTENT_KEY);
export const FfmpegEncoderSubtitleModel = z.enum(Cast.FFMPEG_ENCODER_SUBTITLE);
export const FfmpegEncoderVideoModel = z.enum(Cast.FFMPEG_ENCODER_VIDEO);
export const FfmpegFormatModel = z.enum(Cast.FFMPEG_FORMAT);
export const FfmpegFormatContentKeyModel = z.enum(Cast.FFMPEG_FORMAT_CONTENT_KEY);
export const FfmpegStrictOptionModel = z.enum(Cast.FFMPEG_STRICT_OPTION);
export const FontFormatModel = z.enum(Cast.FONT_FORMAT);
export const ImageMagicColorMatrixModel = z.object({
    row: z.number().int().gte(0),
    column: z.number().int().gte(0),
    value: z.array(z.number()),
});
export const ImageMagickChannelModel = z.enum(Cast.IMAGE_MAGICK_CHANNEL);
export const ImageMagickColorSpaceModel = z.enum(Cast.IMAGE_MAGICK_COLOR_SPACE);
export const ImageMagickCompressionModel = z.enum(Cast.IMAGE_MAGICK_COMPRESSION);
export const ImageMagickFormatModel = z.enum(Cast.IMAGE_MAGICK_FORMAT);
export const ImageMagickGravityModel = z.enum(Cast.IMAGE_MAGICK_GRAVITY);
export const ImageMagickInputFormatModel = z.enum(Cast.IMAGE_MAGICK_INPUT_FORMAT);
export const ImageMagickOutputFormatModel = z.enum(Cast.IMAGE_MAGICK_OUTPUT_FORMAT);
export const InkscapeExportFormatModel = z.enum(Cast.INKSCAPE_EXPORT_FORMAT);
export const LibreOfficeInputFormatModel = z.enum(Cast.LIBRE_OFFICE_INPUT_FORMAT);
export const LibreOfficeOutputFormatModel = z.enum(Cast.LIBRE_OFFICE_OUTPUT_FORMAT);
export const LlvmArchitectureModel = z.enum(Cast.LLVM_ARCHITECTURE);
export const LlvmCpuModel = z.enum(Cast.LLVM_CPU);
export const LlvmFeatureModel = z.enum(Cast.LLVM_FEATURE);
export const LlvmOptimizationLevelModel = z.enum(Cast.LLVM_OPTIMIZATION_LEVEL);
export const PandocFormatContentKeyModel = z.enum(Cast.PANDOC_FORMAT_CONTENT_KEY);
export const PandocInputFormatModel = z.enum(Cast.PANDOC_INPUT_FORMAT);
export const PandocOutputFormatModel = z.enum(Cast.PANDOC_OUTPUT_FORMAT);
export const PuppeteerLifeCycleEventModel = z.enum(Cast.PUPPETEER_LIFE_CYCLE_EVENT);
export const SanitizeHtmlFromContentModel = z.object({
    input: z.object({
        content: z.string(),
    }),
});
export const SlicePdfModel = z.object({
    input: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
    startPage: z.number().int().gte(0),
    endPage: z.number().int().gte(0),
    output: z.object({
        file: z.object({
            path: z.string(),
        }),
    }),
});
export const SlicePdfUsingBytesModel = z.object({
    input: z.object({
        file: z.object({
            buffer: z.instanceof(ArrayBuffer),
        }),
    }),
    startPage: z.number().int().gte(0),
    endPage: z.number().int().gte(0),
    output: z.object({
        file: z.object({
            buffer: z.instanceof(ArrayBuffer),
        }),
    }),
});
export const TaskModel = z.enum(Cast.TASK);
export const UnarchiverFormatKeyModel = z.enum(Cast.UNARCHIVER_FORMAT_KEY);
//# sourceMappingURL=take.js.map