/**
 * Copyright 2023 Design Barn Inc.
 */

export const TITLES = {
  custom: 'custom',
  string: {
    assetImageType: 'asset-image-type',
    assetType: 'asset-type',
    author: 'author',
    character: 'character',
    cssClass: 'css-class',
    description: 'description',
    expression: 'expression',
    filename: 'filename',
    fontCssClass: 'font-css-class',
    fontFamily: 'font-family',
    fontName: 'font-name',
    fontPath: 'font-path',
    fontStyle: 'font-style',
    fontWeight: 'font-weight',
    generator: 'generator',
    hexColor: 'hex-color',
    idAssetImage: 'id-asset-image',
    idAssetPrecomposition: 'id-asset-precomposition',
    idAssetDataSource: 'id-asset-data-source',
    idAssetFile: 'id-asset-file',
    idDataSource: 'data-source-id',
    idImage: 'image-id',
    idLayerXml: 'layer-xml-id',
    idReference: 'reference-id',
    idSound: 'sound-id',
    keyword: 'keyword',
    layerXmlTagName: 'layer-xml-tag-name',
    markerComment: 'marker-comment',

    maskMode: 'mask-mode',
    maskModeNone: 'mask-mode-none',
    maskModeAdd: 'mask-mode-add',
    maskModeSubtract: 'mask-mode-subtract',
    maskModeIntersect: 'mask-mode-intersect',
    maskModeLighten: 'mask-mode-lighten',
    maskModeDarken: 'mask-mode-darken',
    maskModeDifference: 'mask-mode-difference',

    matchName: 'match-name',
    name: 'name',
    path: 'path',
    shapeType: 'shape-type',
    strokeDashType: 'stroke-dash-type',
    text: 'text',
    themeColor: 'theme-color',
    version: 'version',
    slotId: 'slot-id',
  },
  number: {
    adaptiveSampleLimit: 'adaptive-sample-limit',
    ascent: 'ascent',

    textBased: 'text-based',
    textBasedCharacters: 'text-based-characters',
    textBasedCharacterExcludingSpaces: 'text-based-character-excluding-spaces',
    textBasedWords: 'text-based-words',
    textBasedLines: 'text-based-lines',

    baselineShift: 'baseline-shift',

    blendMode: 'blend-mode',
    blendModeNormal: 'blend-mode-normal',
    blendModeMultiply: 'blend-mode-multiply',
    blendModeScreen: 'blend-mode-screen',
    blendModeOverlay: 'blend-mode-overlay',
    blendModeDarken: 'blend-mode-darken',
    blendModeLighten: 'blend-mode-lighten',
    blendModeColorDodge: 'blend-mode-color-dodge',
    blendModeColorBurn: 'blend-mode-color-burn',
    blendModeHardLight: 'blend-mode-hard-light',
    blendModeSoftLight: 'blend-mode-soft-light',
    blendModeDifference: 'blend-mode-difference',
    blendModeExclusion: 'blend-mode-exclusion',
    blendModeHue: 'blend-mode-hue',
    blendModeSaturation: 'blend-mode-saturation',
    blendModeColor: 'blend-mode-color',
    blendModeLuminosity: 'blend-mode-luminosity',
    blendModeAdd: 'blend-mode-add',
    blendModeHardMix: 'blend-mode-hard-mix',

    composite: 'composite',
    compositeAbove: 'composite-above',
    compositeBelow: 'composite-below',

    compositionIndex: 'composition-index',
    count: 'count',
    dataSourceType: 'data-source-type',
    effectType: 'effect-type',
    effectValueType: 'effect-value-type',
    expressionPropertyIndex: 'expression-property-index',

    fillRule: 'fill-rule',
    fillRuleNonZero: 'fill-rule-non-zero',
    fillRuleEvenOdd: 'fill-rule-even-odd',

    fontSize: 'font-size',
    framerate: 'framerate',

    gradientType: 'gradient-type',
    gradientTypeLinear: 'gradient-type-linear',
    gradientTypeRadial: 'gradient-type-radial',

    height: 'height',
    inPoint: 'in-point',
    layerStyleType: 'layer-style-type',
    layerType: 'layer-type',
    length: 'length',

    lineCap: 'line-cap',
    lineCapButt: 'line-cap-butt',
    lineCapRound: 'line-cap-round',
    lineCapSquare: 'line-cap-square',

    lineHeight: 'line-height',
    lineJoin: 'line-join',

    lineJoinMiter: 'line-join-miter',
    lineJoinRound: 'line-join-round',
    lineJoinBevel: 'line-join-bevel',

    markerDuration: 'marker-duration',
    markerTime: 'marker-time',

    matteMode: 'matte-mode',
    matteModeNormal: 'matte-mode-normal',
    matteModeAlpha: 'matte-mode-alpha',
    matteModeInvertedAlpha: 'matte-mode-inverted-alpha',
    matteModeLuma: 'matte-mode-luma',
    matteModeInvertedLuma: 'matte-mode-inverted-luma',

    matteParent: 'matte-parent',

    mergeMode: 'merge-mode',
    mergeModeNormal: 'merge-mode-normal',
    mergeModeAdd: 'merge-mode-add',
    mergeModeSubtract: 'merge-mode-subtract',
    mergeModeIntersect: 'merge-mode-intersect',
    mergeModeExcludeIntersections: 'merge-mode-exclude-intersections',

    miterLimitValue: 'miter-limit-value',

    trimMultipleShapes: 'trim-multiple-shapes',
    trimMultipleShapesIndividually: 'trim-multiple-shapes-individually',
    trimMultipleShapesSimultaneously: 'trim-multiple-shapes-simultaneously',

    numberOfProperties: 'number-of-properties',
    outPoint: 'out-point',
    parentIndex: 'parent-index',
    propertyIndex: 'property-index',

    rangeUnits: 'range-units',
    rangeUnitsPercent: 'range-units-percent',
    rangeUnitsIndex: 'range-units-index',

    samplesPerFrame: 'samples-per-frame',

    shapeDirection: 'shape-direction',
    shapeDirectionNormal: 'shape-direction-normal',
    shapeDirectionClockwise: 'shape-direction-clockwise',
    shapeDirectionClockwiseReversed: 'shape-direction-clockwise-reversed',

    shapePathIndex: 'shape-path-index',
    shapePolygonStarType: 'shape-polygon-star-type',
    shutterAngle: 'shutter-angle',
    shutterPhase: 'shutter-phase',
    staticValue: 'static-value',
    textMask: 'text-mask',
    textRangeSelectorMode: 'text-range-selector-mode',
    textTracking: 'text-tracking',

    fontPathOrigin: 'font-path-origin',
    fontPathOriginLocal: 'font-path-origin-local',
    fontPathOriginCssUrl: 'font-path-origin-css-url',
    fontPathOriginScriptUrl: 'font-path-origin-script-url',
    fontPathOriginFonturl: 'font-path-origin-fonturl',

    textCaps: 'text-caps',
    textCapsRegular: 'text-caps-regular',
    textCapsAll: 'text-caps-all',
    textCapsSmall: 'text-caps-small',

    textGrouping: 'text-grouping',
    textGroupingCharacters: 'text-grouping-characters',
    textGroupingWords: 'text-grouping-words',
    textGroupingLine: 'text-grouping-line',
    textGroupingAll: 'text-grouping-all',

    textJustify: 'text-justify',
    textJustifyLeft: 'text-justify-left',
    textJustifyRight: 'text-justify-right',
    textJustifyCenter: 'text-justify-center',
    textJustifyWithLastLineLeft: 'text-justify-with-last-line-left',
    textJustifyWithLastLineRight: 'text-justify-with-last-line-right',
    textJustifyWithLastLineCenter: 'text-justify-with-last-line-center',
    textJustifyWithLastLineFull: 'text-justify-with-last-line-full',

    textShape: 'text-shape',
    textShapeSquare: 'text-shape-square',
    textShapeRampUp: 'text-shape-ramp-up',
    textShapeRampDown: 'text-shape-ramp-down',
    textShapeTriangle: 'text-shape-triangle',
    textShapeRound: 'text-shape-round',
    textShapeSmooth: 'text-shape-smooth',

    textVerticalJustify: 'text-vertical-justify',
    textVerticalJustifyTop: 'text-vertical-justify-top',
    textVerticalJustifyCenter: 'text-vertical-justify-center',
    textVerticalJustifyBottom: 'text-vertical-justify-bottom',

    keyframeTime: 'keyframe-time',
    keyframeListTime: 'keyframe-list-time',
    keyframeValueTime: 'keyframe-value-time',
    positionKeyframeTime: 'position-keyframe-time',
    positionKeyframeListTime: 'position-keyframe-list-time',
    keyframeBezierHandleTime: 'keyframe-bezier-handle-time',
    shapeKeyframeTime: 'shape-keyframe-time',

    keyframeXAxis: 'keyframe-x-axis',
    keyframeListXAxis: 'keyframe-list-x-axis',
    keyframeValueXAxis: 'keyframe-value-x-axis',
    positionKeyframeXAxis: 'position-keyframe-x-axis',
    positionKeyframeListXAxis: 'position-keyframe-list-x-axis',
    keyframeBezierHandleXAxis: 'keyframe-bezier-handle-x-axis',
    keyframeYAxis: 'keyframe-y-axis',
    keyframeListYAxis: 'keyframe-list-y-axis',
    keyframeValueYAxis: 'keyframe-value-y-axis',
    positionKeyframeYAxis: 'position-keyframe-y-axis',
    positionKeyframeListYAxis: 'position-keyframe-list-y-axis',
    keyframeBezierHandleYAxis: 'keyframe-bezier-handle-y-axis',

    timeStart: 'start-time',
    timeStretch: 'time-stretch',
    effectValueIgnored: 'effect-value-ignored',
    effectPropertyCount: 'effect-property-count',
    width: 'width',
  },
  intBoolean: {
    animated: 'animated',
    autoOrient: 'auto-orient',
    collapseTransformNew: 'collapse-transform-new',
    embedded: 'embedded',
    enabled: 'enabled',
    expressible: 'expressible',
    extraComposition: 'extra-composition',
    hold: 'hold',
    randomize: 'randomize',
    threedimensional: 'threedimensional',
    layerThreedimensional: 'layer-threedimensional',
    matteTarget: 'matte-target',
  },
  boolean: {
    bezierClosed: 'bezier-closed',
    collapseTransform: 'collapse-transform',
    hasMask: 'has-mask',
    hidden: 'hidden',
    inverted: 'inverted',
    motionBlurEnabled: 'motion-blur-enabled',
    splitEnabled: 'split-enabled',
    strokeOverFill: 'stroke-over-fill',
  },
  object: {
    animatedColor: 'animated-color',
    animatedColorStatic: 'animated-color-static',
    animatedMultidimensional: 'animated-multidimensional',
    animatedMultidimensionalStatic: 'animated-multidimensional-static',
    animatedPosition: 'animated-position',
    animatedPositionStatic: 'animated-position-static',
    animatedShape: 'animated-shape',
    animatedShapeStatic: 'animated-shape-static',
    animatedValue: 'animated-value',
    animatedValueStatic: 'animated-value-static',
    animation: 'animation',
    assetDataSource: 'asset-data-source',
    assetImage: 'asset-image',
    assetPrecomposition: 'asset-precomposition',
    assetFile: 'asset-file',
    bezier: 'bezier',
    characterData: 'character-data',
    characterPrecomp: 'character-precomp',
    characterShapes: 'character-shapes',
    effectCustom: 'effect-custom',
    effectDisplacementMap: 'effect-displacement-map',
    effectDropShadow: 'effect-drop-shadow',
    effectFill: 'effect-fill',
    effectGaussianBlur: 'effect-gaussian-blur',
    effectMatte3: 'effect-matte3',
    effectMeshWarp: 'effect-mesh-warp',
    effectPaintOverTransparent: 'effect-paint-over-transparent',
    effectProLevels: 'effect-pro-levels',
    effectPuppet: 'effect-puppet',
    effectRadialWipe: 'effect-radial-wipe',
    effectSpherize: 'effect-spherize',
    effectStroke: 'effect-stroke',
    effectTint: 'effect-tint',
    effectTritone: 'effect-tritone',
    effectParamAngle: 'effect-param-angle',
    effectParamCheckbox: 'effect-param-checkbox',
    effectParamColor: 'effect-param-color',
    effectParamDropdown: 'effect-param-dropdown',
    effectParamIgnored: 'effect-param-ignored',
    effectParamLayer: 'effect-param-layer',
    effectParamNoValue: 'effect-param-no-value',
    effectParamPoint: 'effect-param-point',
    effectParamSlider: 'effect-param-slider',
    effectWavy: 'effect-wavy',
    gradientOverlay: 'gradient-overlay',
    keyframe: 'keyframe',
    keyframeBezierHandle: 'keyframe-bezier-handle',
    layerAdjustment: 'layer-adjustment',
    layerAudio: 'layer-audio',
    layerCamera: 'layer-camera',
    layerData: 'layer-data',
    layerGuide: 'layer-guide',
    layerImage: 'layer-image',
    layerImagePlaceholder: 'layer-image-placeholder',
    layerImageSequence: 'layer-image-sequence',
    layerLight: 'layer-light',
    layerNull: 'layer-null',
    layerPrecomposition: 'layer-precomposition',
    layerShape: 'layer-shape',
    layerSolidColor: 'layer-solid-color',
    layerStyleBevelEmboss: 'layer-style-bevel-emboss',
    layerStyleChokeSpread: 'layer-style-choke-spread',
    layerStyleColorOverlay: 'layer-style-color-overlay',
    layerStyleDropShadow: 'layer-style-drop-shadow',
    layerStyleGradientOverlay: 'layer-style-gradient-overlay',
    layerStyleInnerGlow: 'layer-style-inner-glow',
    layerStyleInnerShadow: 'layer-style-inner-shadow',
    layerStyleOuterGlow: 'layer-style-outer-glow',
    layerStyleSatin: 'layer-style-satin',
    layerStyleStroke: 'layer-style-stroke',
    layerText: 'layer-text',
    layerVideo: 'layer-video',
    layerVideoPlaceholder: 'layer-video-placeholder',
    marker: 'marker',
    mask: 'mask',
    positionKeyframe: 'position-keyframe',
    shapeEllipse: 'shape-ellipse',
    shapeFill: 'shape-fill',
    shapeGradientFill: 'shape-gradient-fill',
    shapeGradientStroke: 'shape-gradient-stroke',
    shapeGroup: 'shape-group',
    shapeKeyframe: 'shape-keyframe',
    shapeMerge: 'shape-merge',
    shapeOffsetPath: 'shape-offset-path',
    shapePath: 'shape-path',
    shapePolygon: 'shape-polygon',
    shapePolyStar: 'shape-poly-star',
    shapePuckerBloat: 'shape-pucker-bloat',
    shapeRectangle: 'shape-rectangle',
    shapeRepeater: 'shape-repeater',
    shapeRoundedCorners: 'shape-rounded-corners',
    shapeStar: 'shape-star',
    shapeStroke: 'shape-stroke',
    shapeTransform: 'shape-transform',
    shapeTrim: 'shape-trim',
    shapeTwist: 'shape-twist',
    shapeZigZags: 'shape-zig-zag',
    splitVector: 'split-vector',
    strokeDashDefault: 'stroke-dash-default',
    strokeDashGap: 'stroke-dash-gap',
    strokeDashLength: 'stroke-dash-length',
    strokeDashOffset: 'stroke-dash-offset',
    textFont: 'text-font',
    textRange: 'text-range',
    textDocumentKeyframe: 'text-document-keyframe',
  },
  array: {
    outTangentsValue: 'out-tangents-value',
    assetsChildren: 'assets-children',
    compositionChildren: 'composition-children',
    effectListChildren: 'effect-list-children',
    effectParamListChildren: 'effect-param-list-children',
    extraCompositionsChildren: 'extra-compositions-children',
    bezierInTangentsChildren: 'bezier-in-tangents-children',
    keyframeEndValueChildren: 'keyframe-end-value-children',
    keyframeListChildren: 'keyframe-list-children',
    keyframeValueChildren: 'keyframe-value-children',
    keywordsChildren: 'keywords-children',
    layerStyleChildren: 'layer-style-children',
    layerStyleListChildren: 'layer-style-list-children',
    markersChildren: 'markers-children',
    masksPropertiesChildren: 'masks-properties-children',
    bezierOutTangentsChildren: 'bezier-out-tangents-children',
    positionKeyframeListChildren: 'position-keyframe-list-children',
    shapeKeyframeListChildren: 'shape-keyframe-list-children',
    shapeKeyframeStartChildren: 'shape-keyframe-start-children',
    shapeListChildren: 'shape-list-children',
    staticValuesChildren: 'static-values-children',
    strokeDashListChildren: 'stroke-dash-list-children',
    textRangesChildren: 'text-ranges-children',
    textCharactersChildren: 'text-characters-children',
    textDocumentKeyframesChildren: 'text-document-keyframes-children',
    textFontListChildren: 'text-font-list-children',
    positionKeyframeInTangentsChildren: 'position-keyframe-in-tangents-children',
    positionKeyframeOutTangentsChildren: 'position-keyframe-out-tangents-children',
    bezierVerticesChildren: 'bezier-vertices-children',
    bezierXAxisChildren: 'bezier-x-axis-children',
    bezierYAxisChildren: 'bezier-y-axis-children',
    colorRgbaChildren: 'color-rgba-children',
    documentFillColorChildren: 'document-fill-color-children',
    documentStrokeColorChildren: 'document-stroke-color-children',
    wrapPositionChildren: 'wrap-position-children',
    wrapSizeChildren: 'wrap-size-children',

    // start temporary titles
    composition: 'composition',
    effectList: 'effect-list',
    effectParamList: 'effect-param-list',
    extraCompositions: 'extra-compositions',
    bezierInTangents: 'bezier-in-tangents',
    keyframeEndValue: 'keyframe-end-value',
    keyframeList: 'keyframe-list',
    keyframeValue: 'keyframe-value',
    keywords: 'keywords',
    layerStyle: 'layer-style',
    layerStyleList: 'layer-style-list',
    markers: 'markers',
    masksProperties: 'masks-properties',
    bezierOutTangents: 'bezier-out-tangents',
    positionKeyframeList: 'position-keyframe-list',
    shapeKeyframeList: 'shape-keyframe-list',
    shapeKeyframeStart: 'shape-keyframe-start',
    shapeList: 'shape-list',
    staticValues: 'static-values',
    strokeDashList: 'stroke-dash-list',
    textRanges: 'text-ranges',
    textCharacters: 'text-characters',
    textDocumentKeyframes: 'text-document-keyframes',
    textFontList: 'text-font-list',
    positionKeyframeInTangents: 'position-keyframe-in-tangents',
    positionKeyframeOutTangents: 'position-keyframe-out-tangents',
    bezierVertices: 'bezier-vertices',
    bezierXAxis: 'bezier-x-axis',
    bezierYAxis: 'bezier-y-axis',
    colorRgba: 'color-rgba',
    documentFillColor: 'document-fill-color',
    documentStrokeColor: 'document-stroke-color',
    wrapPosition: 'wrap-position',
    wrapSize: 'wrap-size',
    // end temporary titles
  },
  collection: {
    assets: 'assets',
    composition: 'composition',
    effectList: 'effect-list',
    effectParamList: 'effect-param-list',
    extraCompositions: 'extra-compositions',
    bezierInTangents: 'bezier-in-tangents',
    keyframeEndValue: 'keyframe-end-value',
    keyframeList: 'keyframe-list',
    keyframeValue: 'keyframe-value',
    keywords: 'keywords',
    layerStyle: 'layer-style',
    layerStyleList: 'layer-style-list',
    markers: 'markers',
    masksProperties: 'masks-properties',
    bezierOutTangents: 'bezier-out-tangents',
    positionKeyframeList: 'position-keyframe-list',
    shapeKeyframeList: 'shape-keyframe-list',
    shapeKeyframeStart: 'shape-keyframe-start',
    shapeList: 'shape-list',
    staticValues: 'static-values',
    strokeDashList: 'stroke-dash-list',
    textRanges: 'text-ranges',
    textCharacters: 'text-characters',
    textDocumentKeyframes: 'text-document-keyframes',
    textFontList: 'text-font-list',
    positionKeyframeInTangents: 'position-keyframe-in-tangents',
    positionKeyframeOutTangents: 'position-keyframe-out-tangents',
    bezierVertices: 'bezier-vertices',
    bezierXAxis: 'bezier-x-axis',
    bezierYAxis: 'bezier-y-axis',
    colorRgba: 'color-rgba',
    documentFillColor: 'document-fill-color',
    documentStrokeColor: 'document-stroke-color',
    wrapPosition: 'wrap-position',
    wrapSize: 'wrap-size',
  },
  element: {
    align: 'align',
    altitude: 'altitude',
    amount: 'amount',
    anchorPoint: 'anchor-point',
    angle: 'angle',
    animatedColorProp: 'animated-color-prop',
    animatedGradientColors: 'animated-gradient-colors',
    animatedMultidimensionalProp: 'animated-multidimensional-prop',
    animatedPositionProp: 'animated-position-prop',
    animatedShapeBezier: 'animated-shape-bezier',
    animatedShapeProp: 'animated-shape-prop',
    animatedValueProp: 'animated-value-prop',
    bevelStyle: 'bevel-style',
    textBlur: 'text-blur',
    blurSize: 'blur-size',
    shapeTrimCenter: 'shape-trim-center',
    chokeSpread: 'choke-spread',
    copies: 'copies',
    dilate: 'dilate',
    distance: 'distance',
    effectValueAngle: 'effect-value-angle',
    effectValueCheckbox: 'effect-value-checkbox',
    effectValueColor: 'effect-value-color',
    effectValueDropdown: 'effect-value-dropdown',
    effectValueLayer: 'effect-value-layer',
    effectValuePoint: 'effect-value-point',
    effectValueSlider: 'effect-value-slider',
    textFillBrightness: 'text-fill-brightness',
    textFillColor: 'text-fill-color',
    textFillHue: 'text-fill-hue',
    textFillOpacity: 'text-fill-opacity',
    textFillSaturation: 'text-fill-saturation',
    shapeGradientFillRule: 'shape-gradient-fill-rule',
    firstMargin: 'first-margin',
    forceAlignment: 'force-alignment',
    globalAngle: 'global-angle',
    gradientOverlayScale: 'gradient-overlay-scale',
    highlightAngle: 'highlight-angle',
    highlightColor: 'highlight-color',
    highlightLength: 'highlight-length',
    highlightMode: 'highlight-mode',
    highlightOpacity: 'highlight-opacity',
    innerRadius: 'inner-radius',
    innerRoundness: 'inner-roundness',
    invert: 'invert',
    keyframeInTangent: 'keyframe-in-tangent',
    keyframeListInTangent: 'keyframe-list-in-tangent',
    keyframeValueInTangent: 'keyframe-value-in-tangent',
    positionKeyframeInTangent: 'position-keyframe-in-tangent',
    positionKeyframeListInTangent: 'position-keyframe-list-in-tangent',
    keyframeBezierHandleInTangent: 'keyframe-bezier-handle-in-tangent',
    shapeKeyframeInTangent: 'shape-keyframe-in-tangent',
    keyframeOutTangent: 'keyframe-out-tangent',
    keyframeListOutTangent: 'keyframe-list-out-tangent',
    keyframeValueOutTangent: 'keyframe-value-out-tangent',
    positionKeyframeOutTangent: 'position-keyframe-out-tangent',
    positionKeyframeListOutTangent: 'position-keyframe-list-out-tangent',
    keyframeBezierHandleOutTangent: 'keyframe-bezier-handle-out-tangent',
    shapeKeyframeOutTangent: 'shape-keyframe-out-tangent',
    jitter: 'jitter',
    lastMargin: 'last-margin',
    layerAudioSettings: 'layer-audio-settings',
    layerConceal: 'layer-conceal',
    layerStyleBlendMode: 'layer-style-blend-mode',
    layerStyleColor: 'layer-style-color',
    layerTransform: 'layer-transform',
    audioLevel: 'audio-level',
    lineSpacing: 'line-spacing',
    maskOpacity: 'mask-opacity',
    maskVertices: 'mask-vertices',
    textMaxAmount: 'text-max-amount',
    textMaxEase: 'text-max-ease',
    textMinEase: 'text-min-ease',
    metadata: 'metadata',
    miterLimit: 'miter-limit',
    miterLimitAlternative: 'miter-limit-alternative',
    motionBlur: 'motion-blur',
    noise: 'noise',
    shapeTrimOffset: 'shape-trim-offset',
    shapeFillOpacity: 'shape-fill-opacity',
    shapeGradientFillOpacity: 'shape-gradient-fill-opacity',
    shapeGradientStrokeOpacity: 'shape-gradient-stroke-opacity',
    layerStyleOpacity: 'layer-style-opacity',
    shapeStrokeOpacity: 'shape-stroke-opacity',
    layerTransformOrientation: 'layer-transform-orientation',
    shapeTransformOrientation: 'shape-transform-orientation',
    transformRepeaterOrientation: 'transform-repeater-orientation',
    textStyleOrientation: 'text-style-orientation',
    shapePolygonOuterRadius: 'shape-polygon-outer-radius',
    shapeStarOuterRadius: 'shape-star-outer-radius',
    shapePolygonOuterRoundness: 'shape-polygon-outer-roundness',
    shapeStarOuterRoundness: 'shape-star-outer-roundness',
    perpendicularToPath: 'perpendicular-to-path',
    perspective: 'perspective',
    shapePolygonPoints: 'shape-polygon-points',
    shapeStarPoints: 'shape-star-points',
    shapeZigZagsPoints: 'shape-zig-zags-points',
    polygonRotationClockwise: 'polygon-rotation-clockwise',
    radius: 'radius',
    range: 'range',
    reverse: 'reverse',
    reversePath: 'reverse-path',
    rotationClockwise: 'rotation-clockwise',
    rotationX: 'rotation-x',
    rotationY: 'rotation-y',
    rotationZ: 'rotation-z',
    rounded: 'rounded',
    roundness: 'roundness',
    // scale
    layerTransformScale: 'layer-transform-scale',
    shapeTransformScale: 'shape-transform-scale',
    transformRepeaterScale: 'transform-repeater-scale',
    textStyleScale: 'text-style-scale',
    // scale ends
    selectorSmoothness: 'selector-smoothness',
    shadowColor: 'shadow-color',
    shadowMode: 'shadow-mode',
    shadowOpacity: 'shadow-opacity',
    shape: 'shape',
    shapeEllipseSize: 'shape-ellipse-size',
    shapeFillColor: 'shape-fill-color',
    shapeStrokeColor: 'shape-stroke-color',
    shapeTrimEnd: 'shape-trim-end',
    shapeTrimStart: 'shape-trim-start',
    shapeZigZagSize: 'shape-zig-zag-size',
    shapeRectangleSize: 'shape-rectangle-size',
    layerStyleStrokeSize: 'layer-style-stroke-size',
    // skew
    layerTransformSkew: 'layer-transform-skew',
    shapeTransformSkew: 'shape-transform-skew',
    transformRepeaterSkew: 'transform-repeater-skew',
    textStyleSkew: 'text-style-skew',
    // skew ends
    // skewAxis
    layerTransformSkewAxis: 'layer-transform-skew-axis',
    shapeTransformSkewAxis: 'shape-transform-skew-axis',
    transformRepeaterSkewAxis: 'transform-repeater-skew-axis',
    textStyleSkewAxis: 'text-style-skew-axis',
    // skewAxis ends
    slots: 'slots',
    slot: 'slot',
    slotProperty: 'slot-property',
    smoothness: 'smoothness',
    soften: 'soften',
    source: 'source',
    splitX: 'split-x',
    splitY: 'split-y',
    splitZ: 'split-z',
    startOpacity: 'start-opacity',
    endOpacity: 'end-opacity',
    shapeGradientFillStartPoint: 'shape-gradient-fill-start-point',
    shapeGradientStrokeStartPoint: 'shape-gradient-stroke-start-point',
    shapeGradientFillEndPoint: 'shape-gradient-fill-end-point',
    shapeGradientStrokeEndPoint: 'shape-gradient-stroke-end-point',
    strength: 'strength',
    strokeBrightness: 'stroke-brightness',
    strokeColor: 'stroke-color',
    strokeHue: 'stroke-hue',
    strokeLength: 'stroke-length',
    strokeOpacity: 'stroke-opacity',
    strokeSaturation: 'stroke-saturation',
    strokeWidth: 'stroke-width',
    technique: 'technique',
    textAnimatorData: 'text-animator-data',
    textCharacterData: 'text-character-data',
    textData: 'text-data',
    textStyle: 'text-style',
    textAnimatedDocument: 'text-animated-document',
    textDocument: 'text-document',
    textFonts: 'text-fonts',
    textGroupAlignment: 'text-group-alignment',
    textFollowPath: 'text-follow-path',
    textAlignmentOptions: 'text-alignment-options',
    textSelector: 'text-selector',
    textSelectorEnd: 'text-selector-end',
    textSelectorStart: 'text-selector-start',
    timeRemapping: 'time-remapping',
    letterSpacing: 'letter-spacing',
    transformOpacity: 'transform-opacity',
    transformRepeater: 'transform-repeater',
    translation: 'translation',
    userMetadata: 'user-metadata',
  },
} as const;

export type CustomTitle = typeof TITLES.custom;

export type TitleHelper<T extends string> = T | CustomTitle;

export type ChildrenTitleHelper<T extends string> = T | `${T}-children` | CustomTitle;

export type NumberTitle = TitleHelper<typeof TITLES.number[keyof typeof TITLES.number]>;

export type IntegerBooleanTitle = TitleHelper<typeof TITLES.intBoolean[keyof typeof TITLES.intBoolean]>;

export type StringTitle = TitleHelper<typeof TITLES.string[keyof typeof TITLES.string]>;

export type BooleanTitle = TitleHelper<typeof TITLES.boolean[keyof typeof TITLES.boolean]>;

export type ObjectTitle = ChildrenTitleHelper<typeof TITLES.object[keyof typeof TITLES.object]>;

export type ArrayTitle = ChildrenTitleHelper<typeof TITLES.array[keyof typeof TITLES.array]>;

export type CollectionTitle = TitleHelper<typeof TITLES.collection[keyof typeof TITLES.collection]>;

export type ElementTitle = TitleHelper<typeof TITLES.element[keyof typeof TITLES.element]>;

export type AttributeTitle = NumberTitle | StringTitle | BooleanTitle | IntegerBooleanTitle;

export type ParentTitle = CollectionTitle | ElementTitle | ObjectTitle | ArrayTitle;

export type AnyTitle = AttributeTitle | ParentTitle;