@satisfactory-dev/docs.json.ts 0.6.1

package/lib/CustomParsingTypes/UnrealEngineString.js

@@ -0,0 +1,308 @@
+import ts from 'typescript';
+import { adjust_class_name, create_const_statement, create_index_access, create_literal, create_method_with_type_parameters, create_method_without_type_parameters, create_modifiers, create_property_access, create_this_assignment, create_throw_if, create_type, createClass, createParameter, not, parenthesize, possibly_create_lazy_union, template_expression_from_string, type_reference_node, variable, } from '../TsFactoryWrapper';
+import { object_has_property, value_is_non_array_object, } from './CustomPairingTypes';
+import { is_string, local_ref, } from '../StringStartsWith';
+export const UnrealEngineString_regex = /^([^']+)'(?:"([^"]+)"|([^"]+))'$/;
+export const UnrealEngineString_general_regex = `/(?:[A-Z-][A-Za-z0-9_-]+/)+(?:[A-Z][A-Za-z_0-9-]+\\.[A-Z][A-Za-z_0-9-]+(?:_C)?(?::[A-Z][A-Za-z0-9_]+)?|[A-Z][A-Za-z_]+\\.[A-Z][A-Za-z_]+)`;
+export function string_or_string_array_to_node(value) {
+    if (is_string(value)) {
+        return create_literal(value);
+    }
+    return ts.factory.createUnionTypeNode(value.map(e => create_literal(e)));
+}
+export function is_UnrealEngineString_parent(maybe) {
+    return (value_is_non_array_object(maybe)
+        && 3 === Object.keys(maybe).length
+        && object_has_property(maybe, 'type')
+        && 'string' === maybe.type
+        && object_has_property(maybe, 'minLength')
+        && 1 === maybe.minLength
+        && object_has_property(maybe, 'UnrealEngineString')
+        && (true === maybe.UnrealEngineString
+            || is_UnrealEngineString_object(maybe.UnrealEngineString)));
+}
+export const UnrealEngineString_schema_definitions = {
+    UnrealEngineString_left_string: {
+        type: 'string',
+        pattern: `^(/Script/[A-Z][A-Za-z]+.[A-Z][A-Za-z]+(?:2D)?|${UnrealEngineString_general_regex})$`,
+    },
+    UnrealEngineString_right_string: {
+        type: 'string',
+        pattern: `^${UnrealEngineString_general_regex}$`,
+    },
+    UnrealEngineString_left: {
+        oneOf: [
+            {
+                $ref: local_ref('UnrealEngineString_left_string'),
+            },
+            {
+                type: 'array',
+                minItems: 1,
+                items: {
+                    $ref: local_ref('UnrealEngineString_left_string'),
+                },
+            },
+        ],
+    },
+    UnrealEngineString_right_starts_with: {
+        type: 'string',
+        pattern: `^/(?:[A-Z][A-Za-z_\\-.]+/)+(?:[A-Z][A-Za-z_\\-.]+/|[A-Z][A-Za-z_\\-.]+\\.[A-Z][A-Za-z_\\-]+)$`,
+    },
+    UnrealEngineString_right: { oneOf: [
+            {
+                $ref: local_ref('UnrealEngineString_right_string'),
+            },
+            {
+                type: 'array',
+                minItems: 1,
+                items: {
+                    $ref: local_ref('UnrealEngineString_right_string'),
+                },
+            },
+            {
+                type: 'object',
+                required: ['starts_with'],
+                additionalProperties: false,
+                properties: { starts_with: { oneOf: [
+                            {
+                                $ref: local_ref('UnrealEngineString_right_starts_with'),
+                            },
+                            {
+                                type: 'array',
+                                minItems: 1,
+                                items: {
+                                    $ref: local_ref('UnrealEngineString_right_starts_with'),
+                                },
+                            },
+                        ] } },
+            },
+        ] },
+};
+export const UnrealEngineString_schema = {
+    oneOf: [
+        {
+            type: 'object',
+            required: ['left', 'right'],
+            additionalProperties: false,
+            properties: {
+                left: {
+                    $ref: local_ref('UnrealEngineString_left'),
+                },
+                right: {
+                    $ref: local_ref('UnrealEngineString_right'),
+                },
+            },
+        },
+        {
+            type: 'object',
+            required: ['left'],
+            additionalProperties: false,
+            properties: {
+                left: {
+                    $ref: local_ref('UnrealEngineString_left'),
+                },
+            },
+        },
+        {
+            type: 'object',
+            required: ['right'],
+            additionalProperties: false,
+            properties: {
+                right: {
+                    $ref: local_ref('UnrealEngineString_right'),
+                },
+            },
+        },
+        {
+            type: 'boolean',
+            const: true,
+        },
+    ],
+};
+export const UnrealEngineString_parent_schema = {
+    type: 'object',
+    required: ['type', 'minLength', 'UnrealEngineString'],
+    additionalProperties: false,
+    properties: {
+        type: { type: 'string', const: 'string' },
+        minLength: { type: 'number', const: 1 },
+        UnrealEngineString: UnrealEngineString_schema,
+    },
+};
+export const UnrealEngineString_left_default = [
+    '/Script/Engine.BlueprintGeneratedClass',
+];
+const right_value_starts_with_suffix = '(?:[A-Z][A-Za-z0-9_.]+/)*[A-Z][A-Za-z_.0-9-]+(?::[A-Z][A-Za-z0-9]+)?';
+export class UnrealEngineString {
+    static already_configured = new WeakSet();
+    static ajv_macro_generator(inner) {
+        return (data_from_schema) => {
+            const data = true === data_from_schema ? {} : data_from_schema;
+            const left_value = ('left' in data
+                ? data.left instanceof Array
+                    ? data.left
+                    : [data.left]
+                : UnrealEngineString_left_default).join('|');
+            const right_value = 'right' in data
+                ? `(?:${(data.right instanceof Array
+                    ? data.right
+                    : [
+                        is_string(data.right)
+                            ? data.right
+                            : `(?:${(data.right
+                                .starts_with instanceof Array
+                                ? data.right.starts_with
+                                : [data.right.starts_with])
+                                .map((starts_with) => `${starts_with}${right_value_starts_with_suffix}`)
+                                .join('|')})`,
+                    ]).join('|')})`
+                : UnrealEngineString_general_regex;
+            const regex = `(?:(?:${left_value})'(?:${right_value}|"${right_value}")')`;
+            return {
+                pattern: inner ? regex : `^${regex}$`,
+            };
+        };
+    }
+    static configure_ajv(ajv) {
+        if (this.already_configured.has(ajv)) {
+            return;
+        }
+        this.already_configured.add(ajv);
+        ajv.addKeyword({
+            keyword: 'UnrealEngineString',
+            type: 'string',
+            metaSchema: {
+                $defs: UnrealEngineString_schema_definitions,
+                ...UnrealEngineString_schema,
+            },
+            macro: this.ajv_macro_generator(false),
+        });
+    }
+    static CustomGenerators() {
+        const UnrealEngineString_class = createClass('UnrealEngineString', [
+            ts.factory.createPropertyDeclaration(create_modifiers('readonly'), 'left', undefined, ts.factory.createTypeReferenceNode('left'), undefined),
+            ts.factory.createPropertyDeclaration(create_modifiers('readonly'), 'right', undefined, ts.factory.createTypeReferenceNode('right'), undefined),
+            create_method_without_type_parameters('constructor', ['protected'], [
+                createParameter('left', ts.factory.createTypeReferenceNode('left')),
+                createParameter('right', ts.factory.createTypeReferenceNode('right')),
+            ], [
+                create_this_assignment('left', 'left'),
+                create_this_assignment('right', 'right'),
+            ]),
+            create_method_with_type_parameters('fromString', [
+                ts.factory.createTypeParameterDeclaration(undefined, 'left', create_type('string'), create_type('string')),
+                ts.factory.createTypeParameterDeclaration(undefined, 'right', create_type('string'), create_type('string')),
+            ], [
+                createParameter('value', create_type('string')),
+            ], [
+                create_const_statement(variable('result', ts.factory.createCallExpression(create_property_access(ts.factory.createRegularExpressionLiteral(UnrealEngineString_regex.toString()), 'exec'), undefined, [
+                    ts.factory.createIdentifier('value'),
+                ]))),
+                create_throw_if('Error', not(ts.factory.createIdentifier('result')), [
+                    template_expression_from_string('`Not an UnrealEngineString (${value})`'),
+                ]),
+                ts.factory.createReturnStatement(ts.factory.createNewExpression(ts.factory.createIdentifier('UnrealEngineString'), [
+                    ts.factory.createTypeReferenceNode('left'),
+                    ts.factory.createTypeReferenceNode('right'),
+                ], [
+                    ts.factory.createAsExpression(create_index_access('result', 1), ts.factory.createTypeReferenceNode('left')),
+                    ts.factory.createAsExpression(parenthesize(ts.factory.createLogicalOr(create_index_access('result', 2), create_index_access('result', 3))), ts.factory.createTypeReferenceNode('right')),
+                ])),
+            ], ['static'], ts.factory.createTypeReferenceNode('UnrealEngineString', [
+                ts.factory.createTypeReferenceNode('left'),
+                ts.factory.createTypeReferenceNode('right'),
+            ])),
+        ], {
+            modifiers: ['export'],
+        }, [
+            ts.factory.createTypeParameterDeclaration(undefined, 'left', create_type('string'), create_type('string')),
+            ts.factory.createTypeParameterDeclaration(undefined, 'right', create_type('string'), create_type('string')),
+        ]);
+        return [
+            {
+                file: 'utils/validators.ts',
+                node: UnrealEngineString_class,
+            },
+        ];
+    }
+}
+export function adjust_unrealengine_value(value) {
+    return adjust_class_name(value.replace(/^\/Script\/FactoryGame\./, ''));
+}
+export function flexibly_create_UnrealEngineString_reference_type(type_arguments) {
+    return type_reference_node('UnrealEngineString', ...(type_arguments || []));
+}
+const empty_object = {};
+export function UnrealEngineString_reference_type(data_from_schema) {
+    const data = true === data_from_schema ? {} : data_from_schema;
+    let left_value = create_literal(UnrealEngineString_left_default[0]);
+    let left_changed = false;
+    let right_value = create_type('string');
+    let right_changed = false;
+    if ('object' === typeof data && 'left' in data) {
+        const { left } = data;
+        const left_options = [
+            ...new Set(left instanceof Array ? left : [left]).values(),
+        ];
+        if (1 === left_options.length) {
+            left_value = create_literal(left_options[0]);
+        }
+        else if (left_options.length > 1) {
+            left_value = possibly_create_lazy_union(left_options);
+        }
+        left_changed = true;
+    }
+    if ('object' === typeof data && 'right' in data) {
+        const { right } = data;
+        if ('object' === typeof right && 'starts_with' in right) {
+            const { starts_with } = right;
+            const right_options = [
+                ...new Set(starts_with instanceof Array ? starts_with : [starts_with]).values(),
+            ];
+            if (right_options.length >= 1) {
+                right_value = type_reference_node('StringStartsWith', (1 === right_options.length
+                    ? create_literal(right_options[0])
+                    : possibly_create_lazy_union(right_options)));
+            }
+        }
+        else {
+            const right_options = [
+                ...new Set(right instanceof Array ? right : [right]).values(),
+            ];
+            if (right_options.length >= 1) {
+                right_value =
+                    1 === right_options.length
+                        ? create_literal(right_options[0])
+                        : possibly_create_lazy_union(right_options);
+            }
+        }
+        right_changed = true;
+    }
+    return flexibly_create_UnrealEngineString_reference_type(left_changed || right_changed
+        ? right_changed
+            ? [left_value, right_value]
+            : [left_value]
+        : undefined);
+}
+function is_string_or_string_array(maybe) {
+    return (is_string(maybe)
+        || (maybe instanceof Array
+            && maybe.length >= 1
+            && maybe.every(is_string)));
+}
+function is_UnrealEngineString_object(maybe) {
+    if (!value_is_non_array_object(maybe)) {
+        return false;
+    }
+    const keys = Object.keys(maybe);
+    const has_left = 'left' in maybe && is_string_or_string_array(maybe.left);
+    const has_right = object_has_property(maybe, 'right')
+        && (value_is_non_array_object(maybe.right)
+            ? 'starts_with' in maybe.right
+                && 1 === Object.keys(maybe.right).length
+                && is_string_or_string_array(maybe.right.starts_with)
+            : is_string_or_string_array(maybe.right));
+    return ((2 === keys.length && has_left && has_right)
+        || (1 === keys.length && (has_left || has_right)));
+}
+//# sourceMappingURL=UnrealEngineString.js.map

package/lib/CustomParsingTypes/ValueToRegexFormatter.d.ts

@@ -0,0 +1,29 @@
+import { SchemaObject } from 'ajv/dist/2020';
+export declare class ValueToRegexFormatter {
+    private typed_string_const;
+    private typed_string_enum;
+    private typed_string_pattern_general;
+    private UnrealEngineString;
+    private readonly $defs;
+    private readonly supported_$ref_object;
+    constructor($defs: {
+        [key: string]: SchemaObject;
+    });
+    pattern_from_value(value: unknown): {
+        pattern: string;
+    };
+    private is_supported_$ref_object;
+    private is_supported_definition;
+    private is_Texture2D_basic;
+    private prepare_$ref_regex;
+    private Texture2D_basic_regex;
+    private typed_string_array_inner_to_regex;
+    private typed_string_object_inner_to_regex;
+    private typed_string_object_pattern_inner_to_regex;
+    private value_to_regex;
+    private static is_typed_string_array_inner;
+    private static is_typed_string_array_prefixItems;
+    private static is_typed_string_object_inner;
+    private static is_typed_string_object_parent;
+    private static is_typed_string_object_pattern_inner;
+}

package/lib/CustomParsingTypes/ValueToRegexFormatter.js

@@ -0,0 +1,205 @@
+import { annoyingly_have_to_escape_property, is_non_empty_array, object_has_non_empty_array_property, object_has_property, object_has_property_that_equals, object_only_has_that_property, value_is_non_array_object, } from './CustomPairingTypes';
+import { is_string, local_ref, } from '../StringStartsWith';
+import { NoMatchError, } from '../Exceptions';
+import { is_UnrealEngineString_parent, UnrealEngineString, } from './UnrealEngineString';
+import { typed_string_const, } from './TypedStringConst';
+import { typed_string_enum, } from './TypedStringEnum';
+import { typed_string_pattern_general, typed_string_pattern_is_supported_schema, typed_string_pattern_value_regex, } from './TypedStringPattern';
+function is_number(maybe) {
+    return 'number' === typeof maybe;
+}
+export class ValueToRegexFormatter {
+    typed_string_const;
+    typed_string_enum;
+    typed_string_pattern_general;
+    UnrealEngineString;
+    $defs;
+    supported_$ref_object;
+    constructor($defs) {
+        this.$defs = $defs;
+        this.UnrealEngineString = UnrealEngineString.ajv_macro_generator(true);
+        this.typed_string_const = typed_string_const;
+        this.typed_string_enum = typed_string_enum;
+        this.typed_string_pattern_general = typed_string_pattern_general;
+        this.supported_$ref_object = this.prepare_$ref_regex($defs);
+    }
+    pattern_from_value(value) {
+        return {
+            pattern: `^${this.value_to_regex(value)}$`,
+        };
+    }
+    is_supported_$ref_object(maybe) {
+        return (object_only_has_that_property(maybe, '$ref', is_string)
+            && object_has_property(this.supported_$ref_object, maybe.$ref));
+    }
+    is_supported_definition(maybe) {
+        return (this.typed_string_const.is_supported_schema(maybe)
+            || this.typed_string_enum.is_supported_schema(maybe)
+            || this.typed_string_pattern_general.is_supported_schema(maybe)
+            || typed_string_pattern_is_supported_schema(maybe)
+            || is_UnrealEngineString_parent(maybe)
+            || ValueToRegexFormatter.is_typed_string_object_parent(maybe)
+            || (object_only_has_that_property(maybe, 'oneOf')
+                && is_non_empty_array(maybe.oneOf, value_is_non_array_object)
+                && maybe.oneOf.every(e => this.is_supported_definition(e))));
+    }
+    is_Texture2D_basic(maybe) {
+        return (value_is_non_array_object(maybe)
+            && 2 === Object.keys(maybe).length
+            && object_has_property_that_equals(maybe, 'type', 'string')
+            && object_has_property_that_equals(maybe, 'string_starts_with', 'Texture2D /Game/FactoryGame/'));
+    }
+    prepare_$ref_regex($defs) {
+        return Object.fromEntries(Object.entries($defs)
+            .filter(maybe => {
+            return this.is_supported_definition(maybe[1]);
+        }).map(entry => {
+            return [
+                local_ref(entry[0]),
+                this.value_to_regex(entry[1]),
+            ];
+        }));
+    }
+    Texture2D_basic_regex() {
+        return `(?:Texture2D \\/Game\\/FactoryGame\\/(?:[A-Z][A-Za-z0-9_.]+/)*[A-Z][A-Za-z_.0-9-]+(?::[A-Z][A-Za-z0-9]+)?)`;
+    }
+    typed_string_array_inner_to_regex(typed_string_array) {
+        const regex = this.value_to_regex(typed_string_array.items);
+        return `\\(${regex}${undefined === typed_string_array.minItems
+            ? ''
+            : `(?:,${regex}){${typed_string_array.minItems - 1},}`}\\)`;
+    }
+    typed_string_object_inner_to_regex(typed_string_object) {
+        return `\\(${Object.entries(typed_string_object.properties).map((entry, index) => {
+            const [property, value] = entry;
+            return `(?:${index > 0
+                ? ','
+                : ''}${annoyingly_have_to_escape_property(property)}=(?:${this.value_to_regex(value)}))${typed_string_object.required.includes(property)
+                ? ''
+                : '?'}`;
+        }).join('')}\\)`;
+    }
+    typed_string_object_pattern_inner_to_regex(typed_string_object) {
+        const [property_regex, value] = Object.entries(typed_string_object.patternProperties)[0];
+        const regex = `(?:${annoyingly_have_to_escape_property(property_regex.substring(1, property_regex.length - 1))})=(?:${this.value_to_regex(value)})`;
+        return `\\(${regex}(,${regex}){${typed_string_object.minProperties - 1},}\\)`;
+    }
+    value_to_regex(value) {
+        if (ValueToRegexFormatter.is_typed_string_object_inner(value)) {
+            return this.typed_string_object_inner_to_regex(value);
+        }
+        else if (ValueToRegexFormatter.is_typed_string_object_pattern_inner(value)) {
+            return this.typed_string_object_pattern_inner_to_regex(value);
+        }
+        else if (ValueToRegexFormatter.is_typed_string_object_parent(value)) {
+            return this.value_to_regex(value.typed_string);
+        }
+        else if (ValueToRegexFormatter.is_typed_string_array_inner(value)) {
+            return this.typed_string_array_inner_to_regex(value);
+        }
+        else if (this.is_supported_$ref_object(value)) {
+            return this.supported_$ref_object[value.$ref];
+        }
+        else if (this.typed_string_const.is_supported_schema(value)) {
+            return this.typed_string_const.value_regex(value);
+        }
+        else if (this.typed_string_enum.is_supported_schema(value)) {
+            return this.typed_string_enum.value_regex(value);
+        }
+        else if (this.typed_string_pattern_general.is_supported_schema(value)) {
+            return this.typed_string_pattern_general.value_regex(value);
+        }
+        else if (typed_string_pattern_is_supported_schema(value)) {
+            return typed_string_pattern_value_regex(value);
+        }
+        else if (is_UnrealEngineString_parent(value)) {
+            return this.UnrealEngineString(value.UnrealEngineString).pattern;
+        }
+        else if (object_has_non_empty_array_property(value, 'oneOf')) {
+            return `(?:${value.oneOf.map(e => this.value_to_regex(e)).join('|')})`;
+        }
+        else if (object_only_has_that_property(value, '$ref', is_string)
+            && value.$ref.startsWith('#/$defs/')
+            && value.$ref.substring(8) in this.$defs
+            && object_only_has_that_property(this.$defs[value.$ref.substring(8)], 'oneOf')
+            && is_non_empty_array(this.$defs[value.$ref.substring(8)].oneOf, value_is_non_array_object)) {
+            const oneOf = this.$defs[value.$ref.substring(8)].oneOf;
+            return `(?:${oneOf
+                .map((e) => this.value_to_regex(e))
+                .join('|')})`;
+        }
+        else if (undefined === this.supported_$ref_object
+            && object_only_has_that_property(value, '$ref', is_string)
+            && value.$ref.startsWith('#/$defs/')
+            && value.$ref.substring(8) in this.$defs
+            && this.is_supported_definition(this.$defs[value.$ref.substring(8)])) {
+            return this.value_to_regex(this.$defs[value.$ref.substring(8)]);
+        }
+        else if (this.is_Texture2D_basic(value)) {
+            return this.Texture2D_basic_regex();
+        }
+        else if (ValueToRegexFormatter.is_typed_string_array_prefixItems(value)) {
+            const item_regex = `\\(${value.prefixItems.map(e => this.value_to_regex(e)).join(', ')}\\)`;
+            return `(?:\\(${item_regex}(?:,${item_regex}){${Math.max(0, value.minItems - 1)},${value.maxItems
+                ? Math.max(1, value.maxItems - 1)
+                : ''}}\\))`;
+        }
+        throw new NoMatchError(value, `Unsupported value! ${JSON.stringify(value)}`);
+    }
+    static is_typed_string_array_inner(maybe) {
+        if (!value_is_non_array_object(maybe)) {
+            return false;
+        }
+        const total_keys = Object.keys(maybe).length;
+        let expected_keys = 3;
+        if (!object_has_property(maybe, 'minItems')) {
+            --expected_keys;
+        }
+        else if (!object_has_property(maybe, 'minItems', is_number)) {
+            throw new NoMatchError(maybe, 'Unsupported minItems value!');
+        }
+        if (!object_has_property(maybe, 'maxItems')) {
+            --expected_keys;
+        }
+        else if (!object_has_property(maybe, 'maxItems', is_number)) {
+            throw new NoMatchError(maybe, 'Unsupported maxItems value!');
+        }
+        return (object_has_property(maybe, 'items')
+            && total_keys === expected_keys);
+    }
+    static is_typed_string_array_prefixItems(maybe) {
+        if (!value_is_non_array_object(maybe)) {
+            return false;
+        }
+        const total_keys = Object.keys(maybe).length;
+        let expected_keys = 4;
+        if (!object_has_property(maybe, 'maxItems')) {
+            --expected_keys;
+        }
+        else if (!object_has_property(maybe, 'maxItems', is_number)) {
+            throw new NoMatchError(maybe, 'Unsupported maxItems value!');
+        }
+        return (object_has_property_that_equals(maybe, 'items', false)
+            && object_has_non_empty_array_property(maybe, 'prefixItems', value_is_non_array_object)
+            && total_keys === expected_keys);
+    }
+    static is_typed_string_object_inner(maybe) {
+        return (object_has_non_empty_array_property(maybe, 'required', is_string)
+            && object_has_property(maybe, 'properties', value_is_non_array_object)
+            && 2 === Object.keys(maybe).length);
+    }
+    static is_typed_string_object_parent(maybe) {
+        return (object_has_property_that_equals(maybe, 'type', 'string')
+            && object_has_property_that_equals(maybe, 'minLength', 1)
+            && object_has_property(maybe, 'typed_string')
+            && 3 === Object.keys(maybe).length
+            && (this.is_typed_string_object_inner(maybe.typed_string)
+                || this.is_typed_string_array_inner(maybe.typed_string)));
+    }
+    static is_typed_string_object_pattern_inner(maybe) {
+        return (object_has_property(maybe, 'minProperties', is_number)
+            && object_has_property(maybe, 'patternProperties', value_is_non_array_object)
+            && 2 === Object.keys(maybe).length);
+    }
+}
+//# sourceMappingURL=ValueToRegexFormatter.js.map

package/lib/DataDiscovery/CustomTypes/BooleanOrBooleanExtended.d.ts

@@ -0,0 +1,12 @@
+import Ajv, { SchemaObject } from 'ajv/dist/2020';
+import { local_ref } from '../../StringStartsWith';
+import { ConverterMatchesSchema, ExpressionResult } from '../Generator';
+import { FalseLiteral, NullLiteral, TrueLiteral } from 'typescript';
+export type schema_type = SchemaObject & {
+    $ref: local_ref<'boolean' | 'boolean-extended'>;
+};
+export declare class BooleanConverter extends ConverterMatchesSchema<schema_type, 'True' | 'False' | '', TrueLiteral | FalseLiteral | NullLiteral> {
+    constructor(ajv: Ajv);
+    can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;
+    convert(_: schema_type, raw_data: '' | 'True' | 'False'): Promise<ExpressionResult<NullLiteral | TrueLiteral | FalseLiteral>>;
+}

package/lib/DataDiscovery/CustomTypes/BooleanOrBooleanExtended.js

@@ -0,0 +1,32 @@
+import { local_ref, } from '../../StringStartsWith';
+import { ConverterMatchesSchema, ExpressionResult, } from '../Generator';
+import ts from 'typescript';
+const schema = {
+    type: 'object',
+    required: ['$ref'],
+    additionalProperties: false,
+    properties: {
+        $ref: { type: 'string', enum: [
+                local_ref('boolean'),
+                local_ref('boolean-extended'),
+            ] },
+    },
+};
+export class BooleanConverter extends ConverterMatchesSchema {
+    constructor(ajv) {
+        super(ajv, schema);
+    }
+    can_convert_schema_and_raw_data(schema, raw_data) {
+        return Promise.resolve(this.can_convert_schema(schema) && ('True' === raw_data
+            || 'False' === raw_data
+            || '' === raw_data));
+    }
+    convert(_, raw_data) {
+        return Promise.resolve(new ExpressionResult('' === raw_data
+            ? ts.factory.createNull()
+            : ('True' === raw_data
+                ? ts.factory.createTrue()
+                : ts.factory.createFalse())));
+    }
+}
+//# sourceMappingURL=BooleanOrBooleanExtended.js.map

package/lib/DataDiscovery/CustomTypes/StringStartsWith.d.ts

@@ -0,0 +1,9 @@
+import { ConverterMatchesSchema, ExpressionResult } from '../Generator';
+import Ajv, { SchemaObject } from 'ajv/dist/2020';
+import { RawData } from '../../TypeDefinitionDiscovery/CustomParsingTypes/string_starts_with';
+import ts, { AsExpression } from 'typescript';
+export declare class StringStartsWithConverter extends ConverterMatchesSchema<RawData, string, AsExpression> {
+    constructor(ajv: Ajv);
+    can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;
+    convert(schema: RawData, raw_data: string): Promise<ExpressionResult<ts.AsExpression>>;
+}

package/lib/DataDiscovery/CustomTypes/StringStartsWith.js

@@ -0,0 +1,19 @@
+import { ConverterMatchesSchema, ExpressionResult, } from '../Generator';
+import { schema, } from '../../TypeDefinitionDiscovery/CustomParsingTypes/string_starts_with';
+import { is_string, } from '../../StringStartsWith';
+import ts from 'typescript';
+import { create_literal, type_reference_node, } from '../../TsFactoryWrapper';
+export class StringStartsWithConverter extends ConverterMatchesSchema {
+    constructor(ajv) {
+        super(ajv, schema);
+    }
+    can_convert_schema_and_raw_data(schema, raw_data) {
+        return Promise.resolve(is_string(raw_data)
+            && this.can_convert_schema(schema)
+            && raw_data.startsWith(schema.string_starts_with));
+    }
+    convert(schema, raw_data) {
+        return Promise.resolve(new ExpressionResult(ts.factory.createAsExpression(ts.factory.createStringLiteral(raw_data), type_reference_node('StringStartsWith', create_literal(schema.string_starts_with)))));
+    }
+}
+//# sourceMappingURL=StringStartsWith.js.map

package/lib/DataDiscovery/CustomTypes/TypedString.d.ts

@@ -0,0 +1,23 @@
+import { ConverterMatchesSchema, ExpressionResult } from '../Generator';
+import { typed_string_parent_type } from '../../CustomParsingTypes/TypedString';
+import { SchemaObject } from 'ajv/dist/2020';
+import { DataDiscovery } from '../../DataDiscovery';
+import { ArrayLiteralExpression, ObjectLiteralExpression } from 'typescript';
+export declare class TypedStringConverter extends ConverterMatchesSchema<typed_string_parent_type, string, ArrayLiteralExpression | ObjectLiteralExpression> {
+    private readonly $defs;
+    private readonly discovery;
+    private readonly regex_schema_cache;
+    constructor(discovery: DataDiscovery, $defs: {
+        [key: string]: SchemaObject;
+    });
+    can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;
+    convert(schema: typed_string_parent_type, raw_data: string): Promise<ExpressionResult<ArrayLiteralExpression | ObjectLiteralExpression>>;
+    private check_shallow_array_prefixItems_schema;
+    private check_shallow_array_schema;
+    private check_shallow_array_schema_assert;
+    private convert_array;
+    private convert_object;
+    private convert_object_check_shallow_parse;
+    private convert_object_property_schema;
+    private convert_prefixItems;
+}