@wise/dynamic-flow-client 0.1.1 → 0.1.3

package/build/common/validation/valid-model/utils.js

@@ -0,0 +1,118 @@
+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 { isArray, isBoolean, isEmpty, isNull, isNumber, isString, isUndefined, } from '@transferwise/neptune-validation';
+import { isListArraySchema, isObjectModel, isArraySchema, } from '../../../dynamic-flow-types';
+import { getValidBasicModelOrNull, getValidModelParts, getValidObjectModelParts } from '.';
+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 = filterOutNull(schema.oneOf.map(function (nestedSchema) { return getValidArrayModelOrNull(model, nestedSchema); }));
+    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];
+        if (!model.every(function (item) { return typeof item === expectedType_1; })) {
+            return new Array(model.length).fill(null);
+        }
+    }
+    return model.map(function (childModel) { return getValidBasicModelOrNull(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));
+}
+export function filterOutNull(array) {
+    return array.filter(function (item) { return item !== null; });
+}

package/build/common/validation/validation-failures/index.d.ts

@@ -0,0 +1,23 @@
+import { BlobSchema, NumberSchema, IntegerSchema, Model, Schema, AllOfSchema, OneOfSchema, StringSchema } from '../../../dynamic-flow-types';
+declare function getValidationFailures(value: Model, schema: Schema, isRequired: boolean): string[];
+declare function getStringValidationFailures(value: Model, schema: StringSchema, isRequired?: boolean): string[];
+declare function getNumberValidationFailures(value: Model, schema: AllOfSchema | OneOfSchema | NumberSchema | IntegerSchema, isRequired?: boolean): string[];
+declare function getIntegerValidationFailures(value: Model, schema: AllOfSchema | OneOfSchema | NumberSchema | IntegerSchema, isRequired?: boolean): string[];
+declare function getBooleanValidationFailures(value: Model, _schema: Schema, isRequired?: boolean): string[];
+declare function getConstValidationFailures(value: Model, schema: Schema, isRequired?: boolean): string[];
+declare function getArrayValidationFailures(value: Model, schema: {
+    minItems?: number;
+    maxItems?: number;
+}, isRequired?: boolean): string[];
+declare function getBlobValidationFailures(value: Model, _schema: BlobSchema): string[];
+/**
+ * When validating an object we only checking that it is an object and that it
+ * has the required properties, we do not check if the properties are valid.
+ *
+ * @param value
+ * @param schema
+ */
+declare function getObjectValidationFailures(value: Model, schema: {
+    required?: string[];
+}): string[];
+export { getValidationFailures, getStringValidationFailures, getNumberValidationFailures, getIntegerValidationFailures, getBooleanValidationFailures, getConstValidationFailures, getArrayValidationFailures, getObjectValidationFailures, getBlobValidationFailures, };

package/build/common/validation/validation-failures/index.js

@@ -0,0 +1,140 @@
+import { isArray, isString, isNumber, isInteger, isBoolean, isNull, } from '@transferwise/neptune-validation';
+import { isObjectModel, } from '../../../dynamic-flow-types';
+import { isStringSchema } from '../../../dynamic-flow-types/Schema';
+import { isValidRequired, isValidMinLength, isValidMaxLength, isValidPattern, isValidMaximum, isValidMinimum, isValidMinItems, isValidMaxItems, isValidRequiredArray, } from '../rule-validators';
+function getValidationFailures(value, schema, isRequired) {
+    if (schema["const"]) {
+        return getConstValidationFailures(value, schema, isRequired);
+    }
+    if (isNull(value)) {
+        return isRequired ? ['required'] : [];
+    }
+    if (isStringSchema(schema)) {
+        return getStringValidationFailures(value, schema, isRequired);
+    }
+    switch (schema.type) {
+        case 'number':
+            return getNumberValidationFailures(value, schema, isRequired);
+        case 'integer':
+            return getIntegerValidationFailures(value, schema, isRequired);
+        case 'boolean':
+            return getBooleanValidationFailures(value, schema, isRequired);
+        case 'array':
+            return getArrayValidationFailures(value, schema, isRequired);
+        case 'object':
+            return getObjectValidationFailures(value, schema);
+        default:
+            return [];
+    }
+}
+function getStringValidationFailures(value, schema, isRequired) {
+    if (!isString(value) && !isNull(value)) {
+        return ['type'];
+    }
+    if (value === '' && isRequired) {
+        return ['required'];
+    }
+    var failures = [];
+    if (!isValidRequired(value, isRequired)) {
+        failures.push('required');
+    }
+    if (!isValidMinLength(value, schema.minLength)) {
+        failures.push('minLength');
+    }
+    if (!isValidMaxLength(value, schema.maxLength)) {
+        failures.push('maxLength');
+    }
+    if (!isValidPattern(value, schema.pattern)) {
+        failures.push('pattern');
+    }
+    if (!isValidMinimum(value, schema.minimum)) {
+        failures.push('minimum');
+    }
+    if (!isValidMaximum(value, schema.maximum)) {
+        failures.push('maximum');
+    }
+    return failures;
+}
+function getNumberValidationFailures(value, schema, isRequired) {
+    if (!isNumber(value) && !isNull(value)) {
+        return ['type'];
+    }
+    var failures = [];
+    if (!isValidRequired(value, isRequired)) {
+        failures.push('required');
+    }
+    if (!isValidMinimum(value, schema.minimum)) {
+        failures.push('minimum');
+    }
+    if (!isValidMaximum(value, schema.maximum)) {
+        failures.push('maximum');
+    }
+    return failures;
+}
+function getIntegerValidationFailures(value, schema, isRequired) {
+    if (!isInteger(value)) {
+        return ['type'];
+    }
+    return getNumberValidationFailures(value, schema, isRequired);
+}
+function getBooleanValidationFailures(value, _schema, isRequired) {
+    if (!isBoolean(value) && !isNull(value)) {
+        return ['type'];
+    }
+    var failures = [];
+    if (!isValidRequired(value, isRequired)) {
+        failures.push('required');
+    }
+    return failures;
+}
+function getConstValidationFailures(value, schema, isRequired) {
+    if (!isValidRequired(value, isRequired)) {
+        return ['required'];
+    }
+    if (value !== schema["const"]) {
+        return ['const'];
+    }
+    return [];
+}
+function getArrayValidationFailures(value, schema, isRequired) {
+    if (!isArray(value) && !isNull(value)) {
+        return ['type'];
+    }
+    if (!isValidRequiredArray(value, isRequired)) {
+        return ['required'];
+    }
+    var failures = [];
+    if (!isValidMinItems(value, schema.minItems)) {
+        failures.push('minItems');
+    }
+    if (!isValidMaxItems(value, schema.maxItems)) {
+        failures.push('maxItems');
+    }
+    return failures;
+}
+function getBlobValidationFailures(value, _schema) {
+    if (isNull(value)) {
+        return ['type'];
+    }
+    return [];
+}
+/**
+ * When validating an object we only checking that it is an object and that it
+ * has the required properties, we do not check if the properties are valid.
+ *
+ * @param value
+ * @param schema
+ */
+function getObjectValidationFailures(value, schema) {
+    if (!isObjectModel(value)) {
+        return ['type'];
+    }
+    if (!isArray(schema.required)) {
+        return [];
+    }
+    var allPresent = schema.required
+        .map(function (property) { return typeof value[property] !== 'undefined'; })
+        .reduce(function (propertyInModel, validSoFar) { return propertyInModel && validSoFar; }, true);
+    return allPresent ? [] : ['required'];
+}
+export { getValidationFailures, getStringValidationFailures, getNumberValidationFailures, getIntegerValidationFailures, getBooleanValidationFailures, getConstValidationFailures, getArrayValidationFailures, getObjectValidationFailures, getBlobValidationFailures, };

package/build/common/validation/validation-failures/spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/common/validation/validation-failures/spec.js

@@ -0,0 +1,185 @@
+import { getValidationFailures } from '.';
+describe('Given a library for identifying validation failures', function () {
+    var schema;
+    describe('when value is null and schema required', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'string',
+                minLength: 3,
+                maxLength: 10,
+                pattern: '^[a-z]+$'
+            };
+        });
+        it('should return only required', function () {
+            expect(getValidationFailures(null, schema, true)).toStrictEqual(['required']);
+        });
+    });
+    describe('when validating a string schema', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'string',
+                minLength: 3,
+                maxLength: 6,
+                pattern: '^[a-z]+$'
+            };
+        });
+        it('should return an empty array for valid string', function () {
+            expect(getValidationFailures('string', schema, false)).toStrictEqual([]);
+        });
+        it('should return an empty array for null if not required', function () {
+            expect(getValidationFailures(null, schema, false)).toStrictEqual([]);
+        });
+        it('should return minLength when too short', function () {
+            expect(getValidationFailures('st', schema, false)).toStrictEqual(['minLength']);
+        });
+        it('should return [maxLength] when too long', function () {
+            expect(getValidationFailures('strings', schema, false)).toStrictEqual(['maxLength']);
+        });
+        it('should return [pattern] when does not pass regex', function () {
+            expect(getValidationFailures('STRING', schema, false)).toStrictEqual(['pattern']);
+        });
+        it('should return [type] when incorrect data type', function () {
+            expect(getValidationFailures(1234, schema, false)).toStrictEqual(['type']);
+        });
+    });
+    describe('when validating a string date', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'string',
+                minimum: '2000-01-01T00:00:00Z',
+                maximum: '2010-01-01T00:00:00Z'
+            };
+        });
+        it('should return an empty array for valid date', function () {
+            expect(getValidationFailures('2005-01-01T00:00:00Z', schema, false)).toStrictEqual([]);
+        });
+        it('should return [min] when date is too early', function () {
+            expect(getValidationFailures('1999-01-01T00:00:00Z', schema, false)).toStrictEqual([
+                'minimum',
+            ]);
+        });
+        it('should return [max] when date is too late', function () {
+            expect(getValidationFailures('2011-01-01T00:00:00Z', schema, false)).toStrictEqual([
+                'maximum',
+            ]);
+        });
+    });
+    describe('when validating a number schema', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'number',
+                minimum: 0,
+                maximum: 20
+            };
+        });
+        it('should return an empty array for an integer in range', function () {
+            expect(getValidationFailures(10, schema, false)).toStrictEqual([]);
+        });
+        it('should return an empty array for a float in range', function () {
+            expect(getValidationFailures(12.34, schema, false)).toStrictEqual([]);
+        });
+        it('should return an empty array for a number that matches our min', function () {
+            expect(getValidationFailures(0, schema, false)).toStrictEqual([]);
+        });
+        it('should return an empty array for a number that matches our max', function () {
+            expect(getValidationFailures(20, schema, false)).toStrictEqual([]);
+        });
+        it('should return [min] when number is too low', function () {
+            expect(getValidationFailures(-1, schema, false)).toStrictEqual(['minimum']);
+        });
+        it('should return [max] when number is too high', function () {
+            expect(getValidationFailures(21, schema, false)).toStrictEqual(['maximum']);
+        });
+        it('should return [type] when incorrect data type', function () {
+            expect(getValidationFailures('string', schema, false)).toStrictEqual(['type']);
+        });
+    });
+    describe('when validating an integer schema', function () {
+        beforeEach(function () {
+            schema = { type: 'integer' };
+        });
+        it('should return an empty array for valid integer', function () {
+            expect(getValidationFailures(15, schema, false)).toStrictEqual([]);
+        });
+        it('should return [type] when a number is not an integer', function () {
+            expect(getValidationFailures(12.34, schema, false)).toStrictEqual(['type']);
+        });
+    });
+    describe('when validating a boolean schema', function () {
+        beforeEach(function () {
+            schema = { type: 'boolean' };
+        });
+        it('should return an empty array for valid boolean', function () {
+            expect(getValidationFailures(true, schema, false)).toStrictEqual([]);
+            expect(getValidationFailures(false, schema, false)).toStrictEqual([]);
+        });
+        it('should return [type] when incorrect data type', function () {
+            expect(getValidationFailures(1, schema, false)).toStrictEqual(['type']);
+        });
+    });
+    describe('when validating a const schema', function () {
+        beforeEach(function () {
+            schema = { "const": 'abcd' };
+        });
+        it('should return an empty array when the const matches', function () {
+            expect(getValidationFailures('abcd', schema, false)).toStrictEqual([]);
+        });
+        it("should return ['const'] when the const does not match", function () {
+            expect(getValidationFailures('1234', schema, false)).toStrictEqual(['const']);
+        });
+        it("should return ['const'] when null", function () {
+            expect(getValidationFailures(null, schema, false)).toStrictEqual(['const']);
+        });
+        it("should return ['const'] when undefined", function () {
+            expect(getValidationFailures(undefined, schema, false)) //
+                .toStrictEqual(['const']);
+        });
+    });
+    describe('when validating an array schema', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'array',
+                items: {
+                    type: 'number'
+                },
+                minItems: 2,
+                maxItems: 2
+            };
+        });
+        it('should return an empty array for a valid array', function () {
+            expect(getValidationFailures([1, 2], schema, false)).toStrictEqual([]);
+        });
+        it('should return [minItems] when the array is too small', function () {
+            expect(getValidationFailures([1], schema, false)).toStrictEqual(['minItems']);
+        });
+        it('should return [maxItems] when the array is too big', function () {
+            expect(getValidationFailures([1, 2, 3], schema, false)).toStrictEqual(['maxItems']);
+        });
+        it('should return [type] when incorrect data type', function () {
+            expect(getValidationFailures({ a: 1 }, schema, false)).toStrictEqual(['type']);
+        });
+    });
+    describe('when validating an object schema', function () {
+        beforeEach(function () {
+            schema = {
+                type: 'object',
+                properties: {
+                    a: {
+                        type: 'number'
+                    }
+                },
+                required: ['a'],
+                displayOrder: ['a']
+            };
+        });
+        it('should return an empty array for a valid object', function () {
+            expect(getValidationFailures({ a: 1 }, schema, false)).toStrictEqual([]);
+        });
+        it('should return [required] when required properties are missing', function () {
+            expect(getValidationFailures({}, schema, false)).toStrictEqual(['required']);
+        });
+        it('should return [type] when incorrect data type', function () {
+            expect(getValidationFailures([1], schema, false)).toStrictEqual(['type']);
+        });
+    });
+});

package/build/dynamic-flow-types/Action.d.ts

@@ -0,0 +1,19 @@
+import { HttpMethod } from './core';
+type CoreAction = {
+    $id?: string;
+    data?: Record<string, unknown>;
+    exit?: boolean;
+    method?: HttpMethod;
+    result?: Record<string, unknown>;
+    timeout?: number;
+    url?: string;
+};
+export type Action = CoreAction & {
+    title?: string;
+    type?: 'primary' | 'secondary' | 'link' | 'positive' | 'negative';
+    disabled?: boolean;
+};
+export type ActionResponseBody = {
+    action: Action;
+};
+export {};

package/build/dynamic-flow-types/Action.js

@@ -0,0 +1 @@
+export {};

package/build/dynamic-flow-types/FileUploadSchema.d.ts

@@ -0,0 +1,23 @@
+import { ImageLayout } from './LayoutComponent';
+import { StringSchema } from './Schema';
+export type FileUploadSchema = Omit<StringSchema, 'type' | 'format' | 'source' | 'image' | 'cameraConfig'> & {
+    type: 'string';
+    format: 'base64url';
+    source?: 'camera' | 'file';
+    image?: ImageLayout;
+    cameraConfig?: CameraConfig;
+};
+type CameraConfig = {
+    assets?: {
+        overlay?: string;
+        outline?: string;
+    };
+    direction?: CameraDirection;
+    instructions?: string;
+};
+export declare function isFileUploadSchema(schema: {
+    type?: string;
+    format?: string;
+}): schema is FileUploadSchema;
+export type CameraDirection = 'back' | 'front';
+export {};

package/build/dynamic-flow-types/FileUploadSchema.js

@@ -0,0 +1,3 @@
+export function isFileUploadSchema(schema) {
+    return schema.type === 'string' && schema.format === 'base64url';
+}

package/build/dynamic-flow-types/LayoutComponent.d.ts

@@ -0,0 +1,129 @@
+import { ExternalStepPollingConfiguration } from '../layout/external/useExternalStepPolling';
+import { Action } from './Action';
+import { Schema } from './Schema';
+import { Margin, Size, Icon, Image, Align, Orientation, Reference, Alert } from './core';
+export type LayoutComponent = AlertLayout | BoxLayout | ButtonLayout | ColumnsLayout | DecisionLayout | DividerLayout | ExternalLayout | FormLayout | HeadingLayout | ImageLayout | InfoLayout | ListLayout | LoadingIndicatorLayout | ParagraphLayout | ReviewLayout;
+export type AlertLayout = {
+    type: 'alert';
+} & Alert;
+export type BoxLayout = {
+    type: 'box';
+    components: LayoutComponent[];
+    width?: Size;
+    margin?: Margin;
+    border?: boolean;
+};
+export type ButtonLayout = {
+    type: 'button';
+    action: Action | Reference;
+    margin?: Margin;
+    /**
+     * @deprecated Only supported on web client
+     */
+    size?: Size;
+};
+export type ColumnsLayout = {
+    type: 'columns';
+    left: LayoutComponent[];
+    right: LayoutComponent[];
+    bias?: 'none' | 'left' | 'right';
+    margin?: Margin;
+};
+export type DecisionLayout = {
+    type: 'decision';
+    options: DecisionOption[];
+    margin?: Margin;
+};
+type DecisionOption = {
+    action: Action | Reference;
+    title: string;
+    description?: string;
+    icon?: Icon;
+    image?: Image;
+    disabled?: boolean;
+};
+/**
+ * @deprecated Only supported on web client
+ */
+export type DividerLayout = {
+    type: 'divider';
+    margin?: Margin;
+};
+/**
+ * @deprecated Please use the external feature set instead
+ */
+export type ExternalLayout = {
+    type: 'external';
+    requestUrl: string;
+    polling?: Omit<ExternalStepPollingConfiguration, 'responseHandlers'>;
+    responseHandlers?: ExternalStepPollingConfiguration['responseHandlers'];
+    retryTitle?: string;
+};
+export type FormLayout = {
+    type: 'form';
+    schema: Schema | Reference;
+    margin?: Margin;
+};
+export type HeadingLayout = {
+    type: 'heading';
+    size?: Size;
+    text: string;
+    margin?: Margin;
+    align?: Align;
+};
+export type ImageLayout = {
+    type: 'image';
+    url: string;
+    /**
+     * @deprecated Only supported on web client
+     */
+    text?: string;
+    size?: Size;
+    margin?: Margin;
+};
+export type InfoLayout = {
+    type: 'info';
+    markdown: string;
+    margin?: Margin;
+    align?: Align;
+};
+export type ListLayout = {
+    type: 'list';
+    items: ListItem[];
+    title?: string;
+    margin?: Margin;
+};
+type ListItem = {
+    title: string;
+    description?: string;
+    icon?: Icon;
+    status?: 'positive' | 'neutral' | 'warning';
+};
+export type LoadingIndicatorLayout = {
+    type: 'loading-indicator';
+    margin?: Margin;
+    size?: Size;
+};
+export type ParagraphLayout = {
+    type: 'paragraph';
+    text: string;
+    control?: 'copyable';
+    margin?: Margin;
+    align?: Align;
+};
+export type ReviewLayout = {
+    type: 'review';
+    title?: string;
+    fields: ReviewField[];
+    orientation?: Orientation;
+    margin?: Margin;
+    /**
+     * @deprecated Only supported on web client
+     */
+    action?: Action;
+};
+type ReviewField = {
+    label: string;
+    value: string | number | boolean | null | undefined;
+};
+export {};

package/build/dynamic-flow-types/LayoutComponent.js

@@ -0,0 +1 @@
+export {};

package/build/dynamic-flow-types/Model.d.ts

@@ -0,0 +1,12 @@
+export type BasicModel = boolean | number | string;
+export type ObjectModel = {
+    [key: string]: Model;
+};
+export type ArrayModel = Array<BasicModel | null>;
+export type Model = BasicModel | ObjectModel | ArrayModel | null;
+export declare const isObjectModel: (model: Model) => model is ObjectModel;
+export declare const isNullableObjectModel: (model: Model) => model is ObjectModel | null;
+export declare const isNullableBasicModel: (model: Model) => model is BasicModel | null;
+export declare const isNullableStringModel: (model: Model) => model is string | null;
+export declare const isArrayModel: (model: Model) => model is ArrayModel;
+export declare const isNullableArrayModel: (model: Model) => model is ArrayModel | null;