@squiz/dx-json-schema-lib 1.21.1-alpha.9 → 1.22.1-alpha.0

package/src/JsonValidationService.ts

@@ -11,12 +11,12 @@ import FormattedText from './formatted-text/v1/formattedText.json';
 
 import v1 from './manifest/v1/v1.json';
 import { SchemaValidationError } from './errors/SchemaValidationError';
-import { Draft07, JSONError, JSONSchema, Draft, DraftConfig, isJSONError } from 'json-schema-library';
+import { Draft07, JSONError, JSONSchema, Draft, DraftConfig } from 'json-schema-library';
 
 import { draft07Config } from 'json-schema-library';
 import { MANIFEST_MODELS } from '.';
 import { customFormatValidators } from './validators/customFormatValidators';
-import { AnyPrimitiveType, AnyResolvableType, TypeResolver } from './jsonTypeResolution/arbitraryTypeResolution';
+import { AnyPrimitiveType, AnyResolvableType, TypeResolver } from './jsonTypeResolution/TypeResolver';
 import { JsonResolutionError } from './errors/JsonResolutionError';
 
 const defaultConfig: DraftConfig = {
@@ -166,6 +166,8 @@ export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvab
       {
         ...defaultConfig,
         resolveRef: (schema, rootSchema) => this.doResolveRef(schema, rootSchema),
+        validate: (core, data, schema, pointer) => defaultConfig.validate(core, data, schema, pointer),
+        resolveOneOf: (core, data, schema, pointer) => defaultConfig.resolveOneOf(core, data, schema, pointer),
       },
       metaSchema.root,
     );
@@ -173,15 +175,25 @@ export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvab
     for (const [key, value] of Object.entries(metaSchema.remotes || {})) {
       this.schema.addRemoteSchema(key, value);
     }
+
+    for (const schema of this.typeResolver.validationSchemaDefinitions) {
+      // Please find a better way of doing this.
+      this.schema.addRemoteSchema(`/${schema.title}.json`, schema as JSONSchema);
+      this.schema.addRemoteSchema(`#/${schema.title}.json`, schema as JSONSchema);
+    }
   }
 
   private doResolveRef(schema: JSONSchema, rootSchema: JSONSchema): JSONSchema {
     const initialRef = draft07Config.resolveRef(schema, rootSchema);
-
     if (!initialRef) return initialRef;
     if (!this.typeResolver.isPrimitiveType(initialRef.type)) return initialRef;
 
-    return this.typeResolver.getValidationSchemaForPrimitive(initialRef.type);
+    const validationSchemas = this.typeResolver.getValidationSchemaForPrimitive(initialRef.type);
+    // All validation schemas are pre-compiled as remote schemas and are referenced below
+    const fullValidationSchema = {
+      oneOf: validationSchemas.map((schema) => ({ $ref: `${schema.title}.json` })),
+    };
+    return this.schema.compileSchema(fullValidationSchema);
   }
 
   /**
@@ -218,12 +230,10 @@ export class JSONSchemaService<P extends AnyPrimitiveType, R extends AnyResolvab
         if (!this.typeResolver.isResolvableSchema(schema)) return;
         // If its a resolvable schema, it should exist in a oneOf array with other schemas
         // Including a primitive schema
-        const allPossibleSchemas: Array<JSONSchema> = schema.oneOfSchema.oneOf;
-        if (isJSONError(allPossibleSchemas)) return;
-
-        const primitiveSchema = allPossibleSchemas.find((schema): schema is P =>
-          this.typeResolver.isPrimitiveSchema(schema),
+        const allPossibleSchemaTitles: Array<string> = schema.oneOfSchema.oneOf.map((o: JSONSchema) =>
+          o.$ref.replace('.json', ''),
         );
+        const primitiveSchema = allPossibleSchemaTitles.find((title) => this.typeResolver.isPrimitiveType(title));
         if (!primitiveSchema) return;
 
         const resolver = this.typeResolver.tryGetResolver(primitiveSchema, schema);

package/src/index.ts

@@ -11,4 +11,11 @@ export * from './JsonValidationService';
 export * from './errors/SchemaValidationError';
 export * from './errors/JsonResolutionError';
 
-export * from './jsonTypeResolution';
+export * from './validators/utils/matrixAssetValidator';
+
+export * from './validators/utils/matrixAssetValidator';
+
+export * from './jsonTypeResolution/TypeResolver';
+export * from './jsonTypeResolution/TypeResolverBuilder';
+export * from './primitiveTypes';
+export * from './resolvableTypes';

package/src/jsonTypeResolution/{arbitraryTypeResolution.spec.ts → TypeResolver.spec.ts}

@@ -1,5 +1,5 @@
 import { JSONSchema } from 'json-schema-library';
-import { PrimitiveType, ResolvableType, TypeResolver } from './arbitraryTypeResolution';
+import { PrimitiveType, ResolvableType, TypeResolver } from './TypeResolver';
 
 const defaultSchema: JSONSchema = {
   type: 'object',
@@ -28,64 +28,33 @@ describe('getValidationSchemaForPrimitive', () => {
   it('should return only the primitive schema when no resolvers are defined', () => {
     const primitiveType = primitiveTypeFixture('MyPrimitive');
     const resolvableType = resolvableTypeFixture('MyResolvable');
-    const resolver = new TypeResolver(
-      {
-        MyPrimitive: primitiveType,
-      },
-      {
-        MyResolvable: resolvableType,
-      },
-      {},
-    );
+    const resolver = new TypeResolver([primitiveType], [resolvableType], {});
 
-    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual({
-      oneOf: [primitiveType],
-    });
+    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual([primitiveType]);
   });
 
   it('should return the primitive schema and the resolvable schema when a resolver is defined', () => {
     const primitiveType = primitiveTypeFixture('MyPrimitive');
     const resolvableType = resolvableTypeFixture('MyResolvable');
-    const resolver = new TypeResolver(
-      {
-        MyPrimitive: primitiveType,
-      },
-      {
-        MyResolvable: resolvableType,
+    const resolver = new TypeResolver([primitiveType], [resolvableType], {
+      MyPrimitive: {
+        MyResolvable: () => null,
       },
-      {
-        MyPrimitive: {
-          MyResolvable: () => null,
-        },
-      },
-    );
-
-    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual({
-      oneOf: [primitiveType, resolvableType],
     });
+
+    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual([primitiveType, resolvableType]);
   });
 
   it('should return the primitive schema and the resolvable schema when a resolver is defined for a different primitive', () => {
     const primitiveType = primitiveTypeFixture('MyPrimitive');
     const resolvableType = resolvableTypeFixture('MyResolvable');
-    const resolver = new TypeResolver(
-      {
-        MyPrimitive: primitiveType,
-        MyOtherPrimitive: primitiveTypeFixture('MyOtherPrimitive'),
-      },
-      {
-        MyResolvable: resolvableType,
+    const resolver = new TypeResolver([primitiveType, primitiveTypeFixture('MyOtherPrimitive')], [resolvableType], {
+      MyOtherPrimitive: {
+        MyResolvable: () => null,
       },
-      {
-        MyOtherPrimitive: {
-          MyResolvable: () => null,
-        },
-      },
-    );
-
-    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual({
-      oneOf: [primitiveType],
     });
+
+    expect(resolver.getValidationSchemaForPrimitive('MyPrimitive')).toEqual([primitiveType]);
   });
 
   it('should error when resolver map contains a key not listed in resolver schemas', () => {
@@ -93,20 +62,12 @@ describe('getValidationSchemaForPrimitive', () => {
     const resolvableType = resolvableTypeFixture('MyResolvable');
     expect(
       () =>
-        new TypeResolver<typeof primitiveType, typeof resolvableType>(
-          {
-            MyPrimitive: primitiveType,
-          },
-          {
-            MyResolvable: resolvableType,
+        new TypeResolver<typeof primitiveType, typeof resolvableType>([primitiveType], [resolvableType], {
+          MyPrimitive: {
+            // @ts-expect-error - this is not a valid resolvable type
+            MyOtherResolvable: () => null,
           },
-          {
-            MyPrimitive: {
-              // @ts-expect-error - this is not a valid resolvable type
-              MyOtherResolvable: () => null,
-            },
-          },
-        ),
+        }),
     ).toThrowError();
   });
 
@@ -115,20 +76,12 @@ describe('getValidationSchemaForPrimitive', () => {
     const resolvableType = resolvableTypeFixture('MyResolvable');
     expect(
       () =>
-        new TypeResolver<typeof primitiveType, typeof resolvableType>(
-          {
-            MyPrimitive: primitiveType,
-          },
-          {
-            MyResolvable: resolvableType,
-          },
-          {
-            // @ts-expect-error - this is not a valid primitive type
-            MyOtherPrimitive: {
-              MyResolvable: () => null,
-            },
+        new TypeResolver<typeof primitiveType, typeof resolvableType>([primitiveType], [resolvableType], {
+          // @ts-expect-error - this is not a valid primitive type
+          MyOtherPrimitive: {
+            MyResolvable: () => null,
           },
-        ),
+        }),
     ).toThrowError();
   });
 });

package/src/jsonTypeResolution/{arbitraryTypeResolution.ts → TypeResolver.ts}

@@ -35,7 +35,7 @@ export function ResolvableType<SHAPE, TITLE extends string>(
 }
 export type AnyResolvableType = ResolvableType<string, any>;
 
-type Resolver<INPUT, OUTPUT> = (input: INPUT) => MaybePromise<OUTPUT>;
+export type Resolver<INPUT, OUTPUT> = (input: INPUT) => MaybePromise<OUTPUT>;
 
 /**
  * A JSON Type Resolver class which stores the primitive and resolvable JSON Schema types and their resolvers
@@ -43,27 +43,35 @@ type Resolver<INPUT, OUTPUT> = (input: INPUT) => MaybePromise<OUTPUT>;
  * No serious logic is required here. The class should only provide data access methods and type safety
  */
 export class TypeResolver<P extends AnyPrimitiveType, R extends AnyResolvableType> {
+  private primitives: Map<P['title'], P>;
+  private resolvables: Map<R['title'], R>;
   constructor(
-    private primitives: { [K in P as P['title']]: K },
-    private resolvables: { [K in R as R['title']]: K },
+    primitives: P[],
+    resolvables: R[] = [],
     public resolvers: {
       [PT in P as PT['title']]?: {
         [RT in R as RT['title']]?: Resolver<RT['__shape__'], PT['__shape__']>;
       };
-    },
+    } = {},
   ) {
+    this.primitives = new Map(primitives.map((p) => [p.title, p]));
+    this.resolvables = new Map(resolvables.map((r) => [r.title, r]));
     for (const [primitiveKey, primitiveResolvers] of Object.entries(resolvers) as [string, Record<string, any>][]) {
-      if (!(primitiveKey in primitives)) {
+      if (!this.primitives.has(primitiveKey)) {
         throw new Error('Resolver keys must match a primitive schema');
       }
-      if (!Object.keys(primitiveResolvers).every((k) => k in resolvables)) {
+      if (!Object.keys(primitiveResolvers).every((k) => this.resolvables.has(k))) {
         throw new Error('Primitive resolvers keys must match a resolvable schema');
       }
     }
   }
 
+  get validationSchemaDefinitions() {
+    return [...this.primitives.values(), ...this.resolvables.values()];
+  }
+
   isPrimitiveType(type: string): type is P['title'] {
-    return type in this.primitives;
+    return this.primitives.has(type);
   }
 
   isPrimitiveSchema(schema: JSONSchema): schema is P {
@@ -71,30 +79,26 @@ export class TypeResolver<P extends AnyPrimitiveType, R extends AnyResolvableTyp
   }
 
   isResolvableSchema(schema: JSONSchema): schema is R {
-    return schema.title in this.resolvables;
+    return this.resolvables.has(schema.title);
   }
 
-  getValidationSchemaForPrimitive(type: keyof typeof this.primitives) {
-    const primitiveSchema = this.primitives[type];
-    const validSchemas = [primitiveSchema, ...this.fetchResolvableSchemasForPrimitive(type)];
-
-    return {
-      oneOf: validSchemas,
-    };
+  getValidationSchemaForPrimitive(type: P['title']) {
+    const primitiveSchema = this.primitives.get(type) as JsonResolutionSchema<string>;
+    return [primitiveSchema, ...this.fetchResolvableSchemasForPrimitive(type)];
   }
 
-  private *fetchResolvableSchemasForPrimitive(type: keyof typeof this.primitives) {
+  private *fetchResolvableSchemasForPrimitive(type: P['title']) {
     for (const resolverKey in this.resolvers[type]) {
-      yield this.resolvables[resolverKey];
+      yield this.resolvables.get(resolverKey) as JsonResolutionSchema<string>;
     }
   }
 
-  tryGetResolver<PS extends P, RS extends R>(
-    primitiveSchema: PS,
-    resolvableSchema: RS,
-  ): Resolver<RS['__shape__'], PS['__shape__']> | undefined {
-    if (!(primitiveSchema.title in this.resolvers)) return;
+  tryGetResolver(
+    primitiveSchemaTitle: string,
+    resolvableSchema: R,
+  ): Resolver<R['__shape__'], P['__shape__']> | undefined {
+    if (!(primitiveSchemaTitle in this.resolvers)) return;
     // Sometimes typescript can be insanely annoying
-    return (this.resolvers[primitiveSchema.title as keyof typeof this.resolvers] as any)?.[resolvableSchema.title];
+    return (this.resolvers[primitiveSchemaTitle as keyof typeof this.resolvers] as any)?.[resolvableSchema.title];
   }
 }

package/src/jsonTypeResolution/TypeResolverBuilder.ts

@@ -0,0 +1,43 @@
+import { AnyPrimitiveType, AnyResolvableType, Resolver, TypeResolver } from './TypeResolver';
+
+type TypeResolverFunction<P extends AnyPrimitiveType, R extends AnyResolvableType> = Resolver<
+  R['__shape__'],
+  P['__shape__']
+>;
+
+export class TypeResolverBuilder {
+  private primitives = new Set<AnyPrimitiveType>();
+  private resolvables = new Set<AnyResolvableType>();
+  private resolverMap: Record<string, Record<string, TypeResolverFunction<AnyPrimitiveType, AnyResolvableType>>> = {};
+  static new() {
+    return new TypeResolverBuilder();
+  }
+
+  addPrimitive<P extends AnyPrimitiveType>(primitive: P) {
+    this.primitives.add(primitive);
+    return this;
+  }
+
+  addResolver<P extends AnyPrimitiveType, R extends AnyResolvableType>(
+    primitive: P,
+    resolvable: R,
+    resolver: TypeResolverFunction<P, R>,
+  ) {
+    this.primitives.add(primitive);
+    this.resolvables.add(resolvable);
+    this.resolverMap[primitive.title] ??= {};
+    this.resolverMap[primitive.title][resolvable.title] = resolver as TypeResolverFunction<
+      AnyPrimitiveType,
+      AnyResolvableType
+    >;
+    return this;
+  }
+
+  build() {
+    return new TypeResolver(
+      Array.from(this.primitives.values()),
+      Array.from(this.resolvables.values()),
+      this.resolverMap,
+    );
+  }
+}

package/src/manifest/v1/DxContentMetaSchema.json

@@ -16,7 +16,7 @@
       "allOf": [{ "$ref": "#/definitions/nonNegativeInteger" }, { "default": 0 }]
     },
     "simpleTypes": {
-      "enum": ["array", "boolean", "integer", "null", "number", "object", "string", "FormattedText"]
+      "enum": ["array", "boolean", "integer", "null", "number", "object", "string", "FormattedText", "SquizImage"]
     },
     "stringArray": {
       "type": "array",

package/src/manifest/v1/MatrixAssetSchema.json

@@ -244,7 +244,7 @@
     },
     "additional": {
       "description": "Additional data of an arbitrary nature related to the requested asset, which may include derived information or special child asset information.",
-      "oneOf": [
+      "anyOf": [
         {
           "$ref": "#/definitions/AssetAdditional"
         },
@@ -260,6 +260,27 @@
       ]
     }
   },
+  "if": {
+    "properties": {
+      "type": {
+        "const": "image"
+      }
+    }
+  },
+  "then": {
+    "properties": {
+      "additional": {
+        "allOf": [
+          {
+            "$ref": "#/definitions/AssetFileAdditional"
+          },
+          {
+            "$ref": "#/definitions/AssetImageAdditional"
+          }
+        ]
+      }
+    }
+  },
   "required": [
     "id",
     "type",
@@ -273,7 +294,8 @@
     "published",
     "url",
     "urls",
-    "attributes"
+    "attributes",
+    "additional"
   ],
 
   "definitions": {
@@ -325,7 +347,8 @@
           "modified_readable": "Feb 3, 2023 12:26 PM",
           "modified_unix": 1675387561
         }
-      }
+      },
+      "required": ["file_info"]
     },
     "AssetImageAdditional": {
       "title": "Image additional info",
@@ -337,11 +360,7 @@
           }
         }
       },
-      "allOf": [
-        {
-          "$ref": "#/definitions/AssetFileAdditional"
-        }
-      ]
+      "required": ["varieties"]
     },
     "AssetCalendarEventAdditional": {
       "title": "Calendar Event additional info",
@@ -360,6 +379,7 @@
           }
         }
       },
+      "required": ["event_info"],
       "example": {
         "event_info": {
           "duration": 1800,

package/src/manifest/v1/v1.ts

@@ -63,8 +63,18 @@ export type CoreSchemaMetaSchema2 =
        */
       enum?: true[];
       type?:
-        | ('array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string' | 'FormattedText')
-        | ('array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string' | 'FormattedText')[];
+        | ('array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string' | 'FormattedText' | 'SquizImage')
+        | (
+            | 'array'
+            | 'boolean'
+            | 'integer'
+            | 'null'
+            | 'number'
+            | 'object'
+            | 'string'
+            | 'FormattedText'
+            | 'SquizImage'
+          )[];
       format?:
         | 'date-time'
         | 'email'
@@ -254,7 +264,6 @@ export type CoreSchemaMetaSchema5 =
  */
 export type SchemaArray1 = CoreSchemaMetaSchema5[];
 export type StringArray1 = string[];
-export type ImageAdditionalInfo = FileAdditionalInfo;
 
 export interface ComponentManifest {
   /**
@@ -2654,8 +2663,8 @@ export interface CoreSchemaMetaSchema1 {
    */
   enum?: true[];
   type?:
-    | ('array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string' | 'FormattedText')
-    | ('array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string' | 'FormattedText')[];
+    | ('array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string' | 'FormattedText' | 'SquizImage')
+    | ('array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string' | 'FormattedText' | 'SquizImage')[];
   format?:
     | 'date-time'
     | 'email'
@@ -3147,7 +3156,7 @@ export interface MatrixAssetSchema {
   /**
    * Additional data of an arbitrary nature related to the requested asset, which may include derived information or special child asset information.
    */
-  additional?: AssetAdditionalInfo | FileAdditionalInfo | ImageAdditionalInfo | CalendarEventAdditionalInfo;
+  additional: AssetAdditionalInfo | FileAdditionalInfo | ImageAdditionalInfo | CalendarEventAdditionalInfo;
   [k: string]: unknown;
 }
 export interface MatrixAssetSchema1 {
@@ -3339,14 +3348,14 @@ export interface MatrixAssetSchema1 {
   /**
    * Additional data of an arbitrary nature related to the requested asset, which may include derived information or special child asset information.
    */
-  additional?: AssetAdditionalInfo | FileAdditionalInfo | ImageAdditionalInfo | CalendarEventAdditionalInfo;
+  additional: AssetAdditionalInfo | FileAdditionalInfo | ImageAdditionalInfo | CalendarEventAdditionalInfo;
   [k: string]: unknown;
 }
 export interface AssetAdditionalInfo {
   [k: string]: unknown;
 }
 export interface FileAdditionalInfo {
-  file_info?: {
+  file_info: {
     file_name?: string;
     size_readable?: string;
     size_bytes?: number;
@@ -3358,8 +3367,12 @@ export interface FileAdditionalInfo {
   };
   [k: string]: unknown;
 }
+export interface ImageAdditionalInfo {
+  varieties: MatrixAssetSchema1[];
+  [k: string]: unknown;
+}
 export interface CalendarEventAdditionalInfo {
-  event_info?: {
+  event_info: {
     duration?: number;
     frequency?: string;
     [k: string]: unknown;

package/src/primitiveTypes/FormattedText.ts

@@ -0,0 +1,24 @@
+import { FORMATTED_TEXT_SCHEMAS } from '..';
+import { BaseFormattedNodes, FormattedText } from '../formatted-text/v1/formattedText';
+import { PrimitiveType } from '../jsonTypeResolution/TypeResolver';
+
+export const FormattedTextType = PrimitiveType<FormattedText, 'FormattedText'>({
+  ...FORMATTED_TEXT_SCHEMAS.v1,
+  title: 'FormattedText',
+});
+export type FormattedTextType = typeof FormattedTextType;
+
+export const BaseFormattedTextType = PrimitiveType<BaseFormattedNodes[], 'FormattedText'>({
+  ...FORMATTED_TEXT_SCHEMAS.v1,
+  items: {
+    $ref: '#/definitions/BaseFormattedNodes',
+  },
+  title: 'FormattedText',
+});
+export type BaseFormattedTextType = typeof BaseFormattedTextType;
+
+export const ComponentInputFormattedTextType = PrimitiveType<string, 'FormattedText'>({
+  type: 'string',
+  title: 'FormattedText',
+});
+export type ComponentInputFormattedTextType = typeof ComponentInputFormattedTextType;

package/src/primitiveTypes/SquizImage.ts

@@ -0,0 +1,128 @@
+import { PrimitiveType } from '../jsonTypeResolution/TypeResolver';
+
+interface SquizImageData {
+  width: number;
+  height: number;
+  url: string;
+  mimeType: string;
+  byteSize: number;
+  sha1Hash: string;
+  aspectRatio: string; // Enforced validation of something like /\d+:\d+/
+}
+
+interface SquizImageShape {
+  name: string;
+  alt?: string;
+  caption?: string;
+
+  exif?: import('exif').ExifData;
+
+  imageVariations: {
+    original: SquizImageData;
+    small?: SquizImageData[];
+    medium?: SquizImageData[];
+    large?: SquizImageData[];
+    aspectRatios?: SquizImageData[];
+  };
+}
+export const SquizImageType = PrimitiveType<SquizImageShape, 'SquizImage'>({
+  title: 'SquizImage',
+  type: 'object',
+  properties: {
+    name: {
+      type: 'string',
+    },
+    alt: {
+      type: 'string',
+    },
+    caption: {
+      type: 'string',
+    },
+    exif: {
+      type: 'object',
+      properties: {
+        image: {
+          type: 'object',
+        },
+        thumbnail: {
+          type: 'object',
+        },
+        exif: {
+          type: 'object',
+        },
+        gps: {
+          type: 'object',
+        },
+        interoperability: {
+          type: 'object',
+        },
+        makernote: {
+          type: 'object',
+        },
+      },
+      required: ['image', 'thumbnail', 'exif', 'gps', 'interoperability', 'makernote'],
+    },
+    imageVariations: {
+      type: 'object',
+      properties: {
+        original: { $ref: '#/definitions/SquizImageData' },
+        small: {
+          type: 'array',
+          items: {
+            $ref: '#/definitions/SquizImageData',
+          },
+        },
+        medium: {
+          type: 'array',
+          items: {
+            $ref: '#/definitions/SquizImageData',
+          },
+        },
+        large: {
+          type: 'array',
+          items: {
+            $ref: '#/definitions/SquizImageData',
+          },
+        },
+        aspectRatios: {
+          type: 'array',
+          items: {
+            $ref: '#/definitions/SquizImageData',
+          },
+        },
+      },
+      required: ['original'],
+    },
+  },
+  required: ['name', 'imageVariations'],
+  definitions: {
+    SquizImageData: {
+      type: 'object',
+      properties: {
+        width: {
+          type: 'number',
+        },
+        height: {
+          type: 'number',
+        },
+        url: {
+          type: 'string',
+        },
+        mimeType: {
+          type: 'string',
+        },
+        byteSize: {
+          type: 'number',
+        },
+        sha1Hash: {
+          type: 'string',
+        },
+        aspectRatio: {
+          type: 'string',
+        },
+      },
+      required: ['width', 'height', 'url', 'mimeType', 'byteSize', 'sha1Hash', 'aspectRatio'],
+    },
+  },
+});
+export type SquizImageType = typeof SquizImageType;

package/src/primitiveTypes/index.ts

@@ -0,0 +1,2 @@
+export * from './SquizImage';
+export * from './FormattedText';