@wise/dynamic-flow-client 3.9.0-experimental-bd037e3 → 3.9.0

package/build/legacy/common/utils/is-equal.spec.js

@@ -1,88 +0,0 @@
-import { isEqual } from './is-equal';
-describe('isEqual', function () {
-    describe('primitives', function () {
-        it('will be true for null equality', function () {
-            expect(isEqual(null, null)).toBe(true);
-        });
-        it('will be true for undefined equality', function () {
-            expect(isEqual(undefined, undefined)).toBe(true);
-        });
-        it('will be true for string equality', function () {
-            expect(isEqual('a string', 'a string')).toBe(true);
-            expect(isEqual('', '')).toBe(true);
-        });
-        it('will be true for number equality', function () {
-            expect(isEqual(0, 0)).toBe(true);
-            expect(isEqual(123, 123)).toBe(true);
-            expect(isEqual(123.456, 123.456)).toBe(true);
-            expect(isEqual(123, 123.0)).toBe(true);
-        });
-        it('will be true for boolean equality', function () {
-            expect(isEqual(false, false)).toBe(true);
-            expect(isEqual(true, true)).toBe(true);
-        });
-        it('will be false for null inequality', function () {
-            expect(isEqual(null, undefined)).toBe(false);
-            expect(isEqual(null, '')).toBe(false);
-            expect(isEqual(null, 0)).toBe(false);
-            expect(isEqual(null, {})).toBe(false);
-        });
-        it('will be false for undefined inequality', function () {
-            expect(isEqual(undefined, null)).toBe(false);
-            expect(isEqual(undefined, '')).toBe(false);
-            expect(isEqual(undefined, 0)).toBe(false);
-            expect(isEqual(undefined, {})).toBe(false);
-        });
-        it('will be false for string inequality', function () {
-            expect(isEqual('a string', null)).toBe(false);
-            expect(isEqual('a string', '')).toBe(false);
-            expect(isEqual('a string', 0)).toBe(false);
-            expect(isEqual('a string', {})).toBe(false);
-        });
-        it('will be false for number inequality', function () {
-            expect(isEqual(123, null)).toBe(false);
-            expect(isEqual(123, '')).toBe(false);
-            expect(isEqual(123, 0)).toBe(false);
-            expect(isEqual(123, {})).toBe(false);
-        });
-    });
-    describe('arrays', function () {
-        it('will be true for primitive array equality', function () {
-            expect(isEqual([1, 2, 3], [1, 2, 3])).toBe(true);
-            expect(isEqual(['a', 'b', 'c'], ['a', 'b', 'c'])).toBe(true);
-            expect(isEqual([true, false], [true, false])).toBe(true);
-            expect(isEqual([null, undefined], [null, undefined])).toBe(true);
-        });
-        it('will be true for complex array equality', function () {
-            expect(isEqual([{ a: 1, b: 2 }, { c: { d: 4 } }], [{ a: 1, b: 2 }, { c: { d: 4 } }])).toBe(true);
-            expect(isEqual([{}], [{}])).toBe(true);
-        });
-        it('will be true for nested array equality', function () {
-            expect(isEqual([[1], [2], [3, 4]], [[1], [2], [3, 4]])).toBe(true);
-        });
-        it('will be false for inequivalent arrays', function () {
-            expect(isEqual([1, 2, 3], [4, 5, 6])).toBe(false);
-            expect(isEqual([null], [{}])).toBe(false);
-            expect(isEqual({ a: 'b' }, { b: 'c' })).toBe(false);
-        });
-        it('will be false for differently ordered arrays', function () {
-            expect(isEqual([1, 2, 3], [3, 2, 1])).toBe(false);
-        });
-    });
-    describe('objects', function () {
-        it('will return true for equivalent objects', function () {
-            expect(isEqual({ a: 'b', b: 1 }, { a: 'b', b: 1 })).toBe(true);
-            expect(isEqual({}, {})).toBe(true);
-        });
-        it('will return true for nested equivalent objects', function () {
-            expect(isEqual({ a: 'b', b: { c: { d: 1 } } }, { b: { c: { d: 1 } }, a: 'b' })).toBe(true);
-            expect(isEqual({ a: 'b', b: [1, 2, 3] }, { b: [1, 2, 3], a: 'b' })).toBe(true);
-        });
-        it('will return false for inequivalent objects', function () {
-            expect(isEqual({ a: 'b' }, { b: 1, c: 2 })).toBe(false);
-            expect(isEqual({ a: 'c', b: { c: { d: 1 } } }, { b: { c: { d: 1 } }, a: 'b' })).toBe(false);
-            expect(isEqual({ a: 'b', b: [1, 2, 3] }, { a: 'b', b: [4, 5, 6] })).toBe(false);
-            expect(isEqual({ a: 1 }, { a: 2 })).toBe(false);
-        });
-    });
-});

package/build/legacy/common/utils/misc-utils.js

@@ -1,4 +0,0 @@
-import { isNull, isString } from '../validators';
-export var isBasicError = function (error) {
-    return isString(error) || isNull(error);
-};

package/build/legacy/common/utils/mobile-utils.js

@@ -1,23 +0,0 @@
-export var isMobile = function () { return isMobileScreenSize() && (isTouchScreen() || isMobileUA()); };
-export var isMobileUA = function (userAgent) {
-    if (userAgent === void 0) { userAgent = window.navigator.userAgent; }
-    // eslint-disable-next-line regexp/no-unused-capturing-group
-    return /mobi|\b(iphone|android|blackberry|webos|windows phone)\b/i.test(userAgent);
-};
-export var isMobileScreenSize = function (width, height) {
-    if (width === void 0) { width = window.screen.width; }
-    if (height === void 0) { height = window.screen.height; }
-    return width < 768 || height < 768;
-};
-export var isTouchScreen = function (navigator, matchMedia) {
-    if (navigator === void 0) { navigator = window.navigator; }
-    if (matchMedia === void 0) { matchMedia = window.matchMedia; }
-    if ('maxTouchPoints' in navigator) {
-        return navigator.maxTouchPoints > 0;
-    }
-    var mQ = matchMedia === null || matchMedia === void 0 ? void 0 : matchMedia('(pointer:coarse)');
-    if ((mQ === null || mQ === void 0 ? void 0 : mQ.media) === '(pointer:coarse)') {
-        return Boolean(mQ.matches);
-    }
-    return false;
-};

package/build/legacy/common/utils/mobile-utils.spec.js

@@ -1,71 +0,0 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import { isMobileUA, isMobileScreenSize, isTouchScreen } from './mobile-utils';
-describe('hasMobileUA', function () {
-    it('should return true for iPhone user agent', function () {
-        expect(isMobileUA('Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Mobile/15E148 Safari/604.1')).toBe(true);
-    });
-    it('should return true for Android user agent', function () {
-        expect(isMobileUA('Mozilla/5.0 (Linux; Android 11; Pixel 4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.66 Mobile Safari/537.36')).toBe(true);
-    });
-    it('should return true for BlackBerry user agent', function () {
-        expect(isMobileUA('Mozilla/5.0 (BB10; Touch) AppleWebKit/537.36 (KHTML, like Gecko) Version/10.3.2.2639 Mobile Safari/537.36')).toBe(true);
-    });
-    it('should return true for webOS user agent', function () {
-        expect(isMobileUA('Mozilla/5.0 (webOS/2.2.4; U; en-US) AppleWebKit/534.6 (KHTML, like Gecko) wOSBrowser/234.83 Safari/534.6 Pre/3.0')).toBe(true);
-    });
-    it('should return true for Windows Phone user agent', function () {
-        expect(isMobileUA('Mozilla/5.0 (Windows Phone 10.0; Android 4.2.1; Trident/7.0; Touch; rv:11.0; IEMobile/11.0; NOKIA; Lumia 520) like Gecko')).toBe(true);
-    });
-    it('should return false if user agent indicates desktop', function () {
-        expect(isMobileUA('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.85 Safari/537.36')).toBe(false);
-    });
-});
-describe('hasMobileScreenSize', function () {
-    it('should return true if screen width < 768px', function () {
-        expect(isMobileScreenSize(390, 844)).toBe(true);
-        expect(isMobileScreenSize(844, 390)).toBe(true);
-    });
-    it('should return true if screen height < 768px (landscape mode)', function () {
-        expect(isMobileScreenSize(844, 390)).toBe(true);
-    });
-    it('should return false if screen width > 768px', function () {
-        expect(isMobileScreenSize(1024, 768)).toBe(false);
-    });
-});
-describe('hasTouchScreen', function () {
-    var mockNavigator = {
-        userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36',
-    };
-    it('should return true if the device has a touch screen', function () {
-        expect(isTouchScreen(__assign(__assign({}, mockNavigator), { maxTouchPoints: 1 }))).toBe(true);
-    });
-    it('should return false if the device does not have a touch screen', function () {
-        expect(isTouchScreen(__assign(__assign({}, mockNavigator), { maxTouchPoints: 0 }))).toBe(false);
-    });
-    it('should return true if matchMedia indicates a touch screen', function () {
-        var mockMatchMedia = jest.fn().mockReturnValue({ media: '(pointer:coarse)', matches: true });
-        var result = isTouchScreen(mockNavigator, mockMatchMedia);
-        expect(mockMatchMedia).toHaveBeenCalledWith('(pointer:coarse)');
-        expect(result).toBe(true);
-    });
-    it('should return false if matchMedia does not indicate a touch screen', function () {
-        var mockMatchMedia = jest.fn().mockReturnValue({ media: '(pointer:coarse)', matches: false });
-        var result = isTouchScreen(mockNavigator, mockMatchMedia);
-        expect(mockMatchMedia).toHaveBeenCalledWith('(pointer:coarse)');
-        expect(result).toBe(false);
-    });
-    it('should return false when none of the conditions are met', function () {
-        var result = isTouchScreen(mockNavigator, undefined);
-        expect(result).toBe(false);
-    });
-});

package/build/legacy/common/utils/model-utils.js

@@ -1,33 +0,0 @@
-import { isArray, isBoolean, isNull, isNumber, isString } from '../validators';
-export var isObjectModel = function (model) {
-    return typeof model === 'object' && model !== null && model.constructor === Object;
-};
-export var isNullableObjectModel = function (model) {
-    return isNull(model) || isObjectModel(model);
-};
-export var isNullableBasicModel = function (model) {
-    return isBoolean(model) || isNumber(model) || isString(model) || isNull(model);
-};
-export var isNullableStringModel = function (model) {
-    return isString(model) || isNull(model);
-};
-export var isArrayModel = function (model) {
-    if (isArray(model)) {
-        if (model.length === 0) {
-            return true;
-        }
-        return model.every(function (item) {
-            return typeof item === 'string' ||
-                typeof item === 'number' ||
-                typeof item === 'boolean' ||
-                typeof item === 'object';
-        });
-    }
-    return false;
-};
-export var isNullableArrayModel = function (model) {
-    if (isNull(model)) {
-        return true;
-    }
-    return isArrayModel(model);
-};

package/build/legacy/common/utils/schema-utils.js

@@ -1,113 +0,0 @@
-import { isObject, isUndefined } from '../validators';
-export function isConstSchema(schema) {
-    return !isUndefined(schema === null || schema === void 0 ? void 0 : schema.const);
-}
-export function isNoNConstSchema(schema) {
-    return Boolean(schema) && !isConstSchema(schema);
-}
-export var isReadOnlySchema = function (schema) {
-    return Boolean(schema.readOnly) && isBasicSchema(schema);
-};
-export var isPromotedOneOfSchema = function (schema) {
-    return Boolean(schema.oneOf) && Boolean(schema.promotion);
-};
-export var basicTypes = new Set(['string', 'number', 'integer', 'boolean']);
-export function isBasicSchema(schema) {
-    return (basicTypes.has(schema.type || '') ||
-        ('const' in schema && schema.const !== undefined && !isObject(schema.const)));
-}
-export function isObjectSchema(schema) {
-    return schema.type === 'object';
-}
-export function isOneOfObjectSchema(schema) {
-    return isOneOfSchema(schema) && schema.oneOf.every(function (subSchema) { return subSchema.type === 'object'; });
-}
-export function isOneOfSchema(schema) {
-    return Boolean(schema.oneOf);
-}
-export function isAllOfSchema(schema) {
-    return Boolean(schema.allOf);
-}
-export function isBlobSchema(schema) {
-    return schema.type === 'blob';
-}
-export function isArraySchema(schema) {
-    return schema.type === 'array';
-}
-export function isTupleArraySchema(schema) {
-    if (isArraySchema(schema)) {
-        var schemaItems = schema.items;
-        return Array.isArray(schemaItems);
-    }
-    return false;
-}
-export function isListArraySchema(schema) {
-    if (isArraySchema(schema)) {
-        var schemaItems = schema.items;
-        return !Array.isArray(schemaItems);
-    }
-    return false;
-}
-export function isStringSchema(schema) {
-    return schema.type === 'string';
-}
-export function isPersistAsyncSchema(schema) {
-    return Boolean(schema.persistAsync);
-}
-export function isPersistAsyncFileSchema(schema) {
-    return (isPersistAsyncSchema(schema) &&
-        (isBlobSchema(schema.persistAsync.schema) || isBase64FileSchema(schema.persistAsync.schema)));
-}
-export var isValidationAsyncSchema = function (schema) {
-    return isBasicSchema(schema) && Boolean(schema.validationAsync);
-};
-function isBase64FileSchema(schema) {
-    return schema.type === 'string' && schema.format === 'base64url';
-}
-export function isFileUploadSchema(schema) {
-    return schema.type === 'string' && schema.format === 'base64url';
-}
-export var isMultipleFileUploadSchema = function (schema) {
-    return isListArraySchema(schema) && isPersistAsyncFileSchema(schema.items);
-};
-export var isMultiSelectConstSchema = function (schema) {
-    var _a;
-    if (isListArraySchema(schema)) {
-        var items = schema.items;
-        if (isOneOfSchema(items) && ((_a = items.oneOf) === null || _a === void 0 ? void 0 : _a.every(isConstSchema))) {
-            return true;
-        }
-    }
-    return false;
-};
-export var getSchemaType = function (schema) {
-    // Order of application is important here
-    if (isReadOnlySchema(schema)) {
-        return 'readOnly';
-    }
-    if (isPersistAsyncSchema(schema)) {
-        return 'persistAsync';
-    }
-    if (isValidationAsyncSchema(schema)) {
-        return 'validationAsync';
-    }
-    if (isObjectSchema(schema)) {
-        return 'object';
-    }
-    if (isArraySchema(schema)) {
-        return 'array';
-    }
-    if (isPromotedOneOfSchema(schema)) {
-        return 'promotedOneOf';
-    }
-    if (isOneOfSchema(schema)) {
-        return 'oneOf';
-    }
-    if (isAllOfSchema(schema)) {
-        return 'allOf';
-    }
-    if (isBasicSchema(schema)) {
-        return 'basic';
-    }
-    return null;
-};

package/build/legacy/common/utils/step-utils.js

@@ -1,32 +0,0 @@
-import { isObjectSchema, isFileUploadSchema } from './schema-utils';
-export var isCameraStep = function (step) {
-    return isFormStep(step) && hasSingleAction(step) && hasSingleFileUploadSchemaWithCameraOnly(step);
-};
-var isFormStep = function (step) { return !step.type || step.type === 'form'; };
-var hasSingleAction = function (step) { var _a; return ((_a = step === null || step === void 0 ? void 0 : step.actions) === null || _a === void 0 ? void 0 : _a.length) === 1; };
-var hasSingleFileUploadSchemaWithCameraOnly = function (step) {
-    if (!step.schemas) {
-        return false;
-    }
-    var schemas = filterHiddenSchemas(step.schemas);
-    if ((schemas === null || schemas === void 0 ? void 0 : schemas.length) !== 1) {
-        return false;
-    }
-    var firstSchema = schemas[0];
-    if (!isObjectSchema(firstSchema) || Object.values(firstSchema.properties).length !== 1) {
-        return false;
-    }
-    var childSchema = Object.values(firstSchema.properties)[0];
-    if (!isFileUploadSchema(childSchema)) {
-        return false;
-    }
-    return childSchema.source === 'camera';
-};
-export var filterHiddenSchemas = function (schemas) {
-    return schemas.filter(function (schema) {
-        if (isObjectSchema(schema)) {
-            return Object.values((schema === null || schema === void 0 ? void 0 : schema.properties) || {}).find(function (schema) { return (schema === null || schema === void 0 ? void 0 : schema.hidden) !== true; });
-        }
-        return (schema === null || schema === void 0 ? void 0 : schema.hidden) !== true;
-    });
-};

package/build/legacy/common/validators/index.js

@@ -1,5 +0,0 @@
-export { getValidModelParts, getValidObjectModelParts, getValidBasicModelOrNull, } from './models/model-validators';
-export { isValidSchema } from './schemas/schema-validators';
-export { getValidationFailures, getArrayValidationFailures, } from './validationFailures/validation-failures';
-export * from './types/type-validators';
-export * from './values/value-validators';

package/build/legacy/common/validators/models/model-utils.js

@@ -1,119 +0,0 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import { isObjectModel, isArraySchema, isListArraySchema } from '../../utils';
-import { isArray, isBoolean, isNull, isNumber, isString, isUndefined, } from '../types/type-validators';
-import { isEmpty } from '../values/value-validators';
-import { getValidBasicModelOrNull, getValidModelParts, getValidObjectModelParts, } from './model-validators';
-export function cleanBasicModelWithOneOfSchema(model, schema) {
-    return schema.oneOf.some(function (nestedSchema) { return getValidBasicModelOrNull(model, nestedSchema) === model; })
-        ? model
-        : null;
-}
-export function cleanArrayModelWithOneOfSchema(model, schema) {
-    var _a;
-    var validModels = schema.oneOf
-        .map(function (nestedSchema) { return getValidArrayModelOrNull(model, nestedSchema); })
-        .filter(function (item) { return item !== null; });
-    if (validModels.length === 0) {
-        return null;
-    }
-    return (_a = validModels.find(function (model) { return model.some(function (item) { return item !== null; }); })) !== null && _a !== void 0 ? _a : validModels[0];
-}
-function getValidArrayModelOrNull(model, schema) {
-    if (!isArraySchema(schema)) {
-        return null;
-    }
-    if (!isListArraySchema(schema)) {
-        return null; // we don't support tuples at the moment
-    }
-    return cleanModelWithArraySchema(model, schema);
-}
-export function cleanModelWithStringSchema(model) {
-    return isString(model) && !isEmpty(model) ? model : null;
-}
-export function cleanModelWithNumberSchema(model) {
-    return isNumber(model) ? model : null;
-}
-export function cleanModelWithBooleanSchema(model) {
-    return isBoolean(model) ? model : null;
-}
-export function cleanModelWithArraySchema(model, schema) {
-    if (!isArray(model)) {
-        return null;
-    }
-    if (!isListArraySchema(schema)) {
-        return null; // we don't support tuples at the moment
-    }
-    if (model.length > 0) {
-        var expectedType_1 = typeof model[0];
-        // eslint-disable-next-line valid-typeof
-        if (!model.every(function (item) { return typeof item === expectedType_1; })) {
-            return new Array(model.length).fill(null);
-        }
-    }
-    return model.map(function (childModel) { return getValidModelParts(childModel, schema.items); });
-}
-export function cleanObjectModelWithObjectSchema(model, schema) {
-    return Object.keys(schema.properties).reduce(function (cleanedModel, property) {
-        var _a;
-        // If the property exists in the model, clean it, and add it
-        if (model && !isUndefined(model[property])) {
-            var subModel = model[property];
-            var subSchema = schema.properties[property];
-            var newValue = getValidModelParts(subModel, subSchema);
-            if (!isNull(newValue)) {
-                return __assign(__assign({}, cleanedModel), (_a = {}, _a[property] = newValue, _a));
-            }
-        }
-        return cleanedModel;
-    }, {});
-}
-export function cleanObjectModelWithAllOfSchema(model, schema) {
-    return schema.allOf.reduce(function (cleanObjectModel, nestedSchema) {
-        var validSubsetOfModel = getValidObjectModelParts(model, nestedSchema);
-        if (isObjectModel(validSubsetOfModel)) {
-            // Extend model with valid subset
-            return __assign(__assign({}, cleanObjectModel), validSubsetOfModel);
-        }
-        return cleanObjectModel;
-    }, {});
-}
-export function cleanObjectModelWithOneOfSchema(model, schema) {
-    return schema.oneOf
-        .map(function (nestedSchema) { return getValidObjectModelParts(model, nestedSchema); })
-        .reduce(function (combined, current) {
-        // If we didn't find anything valid yet, and current is good, return it
-        if (isNull(combined)) {
-            return current;
-        }
-        // If we're dealing with two objects, deep merge them into one
-        if (isObjectModel(combined) && isObjectModel(current)) {
-            return deepMergeObject(combined, current);
-        }
-        // If the current one is null, return what we already had
-        if (isNull(current)) {
-            return combined;
-        }
-        return current;
-    }, null);
-}
-function deepMergeObject(object1, object2) {
-    return Object.keys(object2).reduce(function (acc, property) {
-        var _a, _b;
-        var object1Property = object1[property];
-        var object2Property = object2[property];
-        if (isObjectModel(object1Property) && isObjectModel(object2Property)) {
-            return __assign(__assign({}, acc), (_a = {}, _a[property] = deepMergeObject(object1Property, object2Property), _a));
-        }
-        return __assign(__assign({}, acc), (_b = {}, _b[property] = object2[property], _b));
-    }, __assign({}, object1));
-}

package/build/legacy/common/validators/models/model-utils.spec.js

@@ -1,45 +0,0 @@
-import { cleanModelWithArraySchema } from './model-utils';
-var basicArray = {
-    type: 'array',
-    items: {
-        title: 'Email',
-        type: 'string',
-    },
-};
-var objectArray = {
-    type: 'array',
-    addItemTitle: '',
-    editItemTitle: '',
-    items: {
-        type: 'object',
-        displayOrder: ['name', 'terms'],
-        properties: {
-            name: {
-                title: 'Full name',
-                type: 'string',
-            },
-            terms: {
-                title: 'I agree to the terms and conditions',
-                type: 'boolean',
-            },
-        },
-    },
-};
-describe('cleanModelWithArraySchema', function () {
-    it('should return null if the model is not an array', function () {
-        expect(cleanModelWithArraySchema('foo', basicArray)).toBeNull();
-    });
-    it('should return an empty array if the model is an empty array', function () {
-        expect(cleanModelWithArraySchema([], basicArray)).toStrictEqual([]);
-    });
-    // This is kind of strange behaviour, but it's existing, so I don't want to change it
-    it('should return an array of nulls if the model has items with different types', function () {
-        expect(cleanModelWithArraySchema(['foo', 1], basicArray)).toStrictEqual([null, null]);
-    });
-    it('should return the model if the model is a non-empty array', function () {
-        expect(cleanModelWithArraySchema(['foo'], basicArray)).toStrictEqual(['foo']);
-    });
-    it('should return valid model parts of each item in the array', function () {
-        expect(cleanModelWithArraySchema([{ name: 'foo', terms: true }, { cat: 'chaos' }], objectArray)).toStrictEqual([{ name: 'foo', terms: true }, {}]);
-    });
-});

package/build/legacy/common/validators/models/model-validators.js

@@ -1,62 +0,0 @@
-import { isArrayModel, isObjectModel, isBasicSchema, isOneOfSchema, isArraySchema, isObjectSchema, isEqual, } from '../../utils';
-import { isNull, isUndefined } from '..';
-import { cleanArrayModelWithOneOfSchema, cleanBasicModelWithOneOfSchema, cleanModelWithArraySchema, cleanModelWithBooleanSchema, cleanModelWithNumberSchema, cleanModelWithStringSchema, cleanObjectModelWithAllOfSchema, cleanObjectModelWithObjectSchema, cleanObjectModelWithOneOfSchema, } from './model-utils';
-export var getValidModelParts = function (model, schema) {
-    if (isObjectModel(model)) {
-        return getValidObjectModelParts(model, schema);
-    }
-    if (isArrayModel(model)) {
-        return getValidArrayModelParts(model, schema);
-    }
-    return getValidBasicModelOrNull(model, schema);
-};
-export function getValidBasicModelOrNull(model, schema) {
-    if (isNull(model)) {
-        return null;
-    }
-    if (schema.oneOf) {
-        return cleanBasicModelWithOneOfSchema(model, schema);
-    }
-    if (!isUndefined(schema.const) && model === schema.const) {
-        return model;
-    }
-    if (schema.type) {
-        switch (schema.type) {
-            case 'string':
-                return cleanModelWithStringSchema(model);
-            case 'number':
-            case 'integer':
-                return cleanModelWithNumberSchema(model);
-            case 'boolean':
-                return cleanModelWithBooleanSchema(model);
-            default:
-                return null;
-        }
-    }
-    // Unrecognised schema
-    return null;
-}
-export function getValidObjectModelParts(model, schema) {
-    if (isBasicSchema(schema) || isArraySchema(schema) || isNull(model)) {
-        return null;
-    }
-    if (schema.allOf) {
-        return cleanObjectModelWithAllOfSchema(model, schema);
-    }
-    if (schema.oneOf) {
-        return cleanObjectModelWithOneOfSchema(model, schema);
-    }
-    if (!isUndefined(schema.const) && isEqual(model, schema.const)) {
-        return model;
-    }
-    return isObjectSchema(schema) ? cleanObjectModelWithObjectSchema(model, schema) : null;
-}
-function getValidArrayModelParts(model, schema) {
-    if (isOneOfSchema(schema)) {
-        return cleanArrayModelWithOneOfSchema(model, schema);
-    }
-    if (!isArraySchema(schema)) {
-        return null;
-    }
-    return cleanModelWithArraySchema(model, schema);
-}