diff --git a/docs/jupiterone.md b/docs/jupiterone.md
index b05b3a9..2108eee 100644
--- a/docs/jupiterone.md
+++ b/docs/jupiterone.md
@@ -83,7 +83,7 @@ The following entities are created:
 | Consumable | `snipeit_consumable_resource`  | `Resource`      |
 | Hardware   | `snipeit_hardware`             | `Device`        |
 | License    | `snipeit_licensed_application` | `Application`   |
-| Location   | `location`                     | `Site`          |
+| Location   | `snipeit_location`             | `Site`          |
 | Service    | `snipeit_service`              | `Service`       |
 | User       | `snipeit_user`                 | `User`          |
 
@@ -93,10 +93,10 @@ The following relationships are created:
 
 | Source Entity `_type` | Relationship `_class` | Target Entity `_type`          |
 | --------------------- | --------------------- | ------------------------------ |
-| `snipeit_account`     | **MANAGES**           | `location`                     |
 | `snipeit_account`     | **HAS**               | `snipeit_consumable_resource`  |
 | `snipeit_account`     | **MANAGES**           | `snipeit_hardware`             |
 | `snipeit_account`     | **HAS**               | `snipeit_licensed_application` |
+| `snipeit_account`     | **MANAGES**           | `snipeit_location`             |
 | `snipeit_account`     | **PROVIDES**          | `snipeit_service`              |
 | `snipeit_account`     | **HAS**               | `snipeit_user`                 |
 | `snipeit_hardware`    | **INSTALLED**         | `snipeit_licensed_application` |
@@ -109,8 +109,8 @@ The following mapped relationships are created:
 
 | Source Entity `_type` | Relationship `_class` | Target Entity `_type` | Direction |
 | --------------------- | --------------------- | --------------------- | --------- |
-| `location`            | **HAS**               | `*snipeit_hardware*`  | FORWARD   |
-| `snipeit_user`        | **IS**                | `*person*`            | FORWARD   |
+| `snipeit_location`    | **HAS**               | `*snipeit_hardware*`  | FORWARD   |
+| `snipeit_user`        | **IS**                | `*snipeit_person*`    | FORWARD   |
 
 <!--
 ********************************************************************************
diff --git a/src/entities.ts b/src/entities.ts
new file mode 100644
index 0000000..0621395
--- /dev/null
+++ b/src/entities.ts
@@ -0,0 +1,481 @@
+import { SchemaType } from '@jupiterone/integration-sdk-core';
+import { createEntityType, createEntityMetadata } from './helpers';
+
+export type HardwareAssignmentType = 'user' | 'asset' | 'location';
+
+export const [AccountEntityMetadata, createAccountAssignEntity] =
+  createEntityMetadata({
+    resourceName: 'Account',
+    _class: ['Account'],
+    _type: createEntityType('account'),
+    description: 'Snipe-IT Account',
+    schema: SchemaType.Object({
+      name: SchemaType.String(),
+      displayName: SchemaType.String(),
+      description: SchemaType.Optional(SchemaType.String()),
+      vendor: SchemaType.String(),
+    }),
+  });
+
+export const [ServiceEntityMetadata, createServiceAssignEntity] =
+  createEntityMetadata({
+    resourceName: 'Service',
+    _class: ['Service'],
+    _type: createEntityType('service'),
+    description: 'Snipe-IT Service',
+    schema: SchemaType.Object({}),
+  });
+
+export const [LocationEntityMetadata, createLocationAssignEntity] =
+  createEntityMetadata({
+    resourceName: 'Location',
+    _class: ['Site'],
+    _type: createEntityType('location'),
+    description: 'Snipe-IT Location',
+    schema: SchemaType.Object({
+      locationId: SchemaType.Number(),
+      image: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      address: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      address2: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      city: SchemaType.String(),
+      state: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      country: SchemaType.String(),
+      zip: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      assignedAssetsCount: SchemaType.Number(),
+      assetsCount: SchemaType.Number(),
+      rtdAssetsCount: SchemaType.Number(),
+      usersCount: SchemaType.Number(),
+      currency: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      isUpdateActionAvailable: SchemaType.Optional(SchemaType.Boolean()),
+      isDeleteActionAvailable: SchemaType.Optional(SchemaType.Boolean()),
+      isCloneActionAvailable: SchemaType.Optional(SchemaType.Boolean()),
+    }),
+  });
+
+export const [HardwareEntityMetadata, createHardwareAssignEntity] =
+  createEntityMetadata({
+    resourceName: 'Hardware',
+    _class: ['Device'],
+    _type: createEntityType('hardware'),
+    description: 'Snipe-IT Hardware',
+    schema: SchemaType.Object({
+      assignedType: SchemaType.Optional(
+        SchemaType.Union([
+          SchemaType.Literal('user'),
+          SchemaType.Literal('asset'),
+          SchemaType.Literal('location'),
+        ]),
+      ),
+      assignedName: SchemaType.Optional(SchemaType.String()),
+      company: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      byod: SchemaType.Boolean({
+        deprecated: true,
+        description: 'Please use BYOD instead.',
+      }),
+      supplier: SchemaType.Optional(SchemaType.String()),
+      EOL: SchemaType.Boolean(),
+      locationId: SchemaType.Optional(SchemaType.Number()),
+      statusMeta: SchemaType.String(SchemaType.String()),
+      statusName: SchemaType.String(SchemaType.String()),
+      purchaseCost: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+    }),
+  });
+
+export const [ConsumableEntityMetadata, createConsumableAssignEntity] =
+  createEntityMetadata({
+    resourceName: 'Consumable',
+    _class: ['Resource'],
+    _type: createEntityType('consumable_resource'),
+    description: 'Snipe-IT Consumable',
+    schema: SchemaType.Object({
+      consumableId: SchemaType.Number(),
+      image: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      'category.id': SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use categoryId instead.',
+        }),
+      ),
+      categoryId: SchemaType.Optional(SchemaType.Number()),
+      'category.name': SchemaType.Optional(
+        SchemaType.String({
+          deprecated: true,
+          description: 'Please use categoryName instead.',
+        }),
+      ),
+      categoryName: SchemaType.Optional(SchemaType.String()),
+      'company.id': SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use companyId instead.',
+        }),
+      ),
+      companyId: SchemaType.Optional(SchemaType.Number()),
+      'company.name': SchemaType.Optional(
+        SchemaType.String({
+          deprecated: true,
+          description: 'Please use companyName instead.',
+        }),
+      ),
+      companyName: SchemaType.Optional(SchemaType.String()),
+      itemNo: SchemaType.Optional(SchemaType.String()),
+      'location.id': SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use locationId instead.',
+        }),
+      ),
+      locationId: SchemaType.Optional(SchemaType.Number()),
+      'location.name': SchemaType.Optional(
+        SchemaType.String({
+          deprecated: true,
+          description: 'Please use locationName instead.',
+        }),
+      ),
+      locationName: SchemaType.Optional(SchemaType.String()),
+      'manufacturer.id': SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use manufacturerId instead.',
+        }),
+      ),
+      manufacturerId: SchemaType.Optional(SchemaType.Number()),
+      'manufacturer.name': SchemaType.Optional(
+        SchemaType.String({
+          deprecated: true,
+          description: 'Please use manufacturerName instead.',
+        }),
+      ),
+      manufacturerName: SchemaType.Optional(SchemaType.String()),
+      minAmt: SchemaType.Optional(SchemaType.Number()),
+      modelNumber: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      remaining: SchemaType.Optional(SchemaType.Number()),
+      orderNumber: SchemaType.Optional(SchemaType.String()),
+      purchaseCost: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      purchaseDate: SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use purchasedOn instead.',
+        }),
+      ),
+      purchasedOn: SchemaType.Optional(SchemaType.Number()),
+      qty: SchemaType.Optional(SchemaType.Number()),
+      notes: SchemaType.Optional(SchemaType.Array(SchemaType.String())),
+      userCanCheckout: SchemaType.Optional(
+        SchemaType.Boolean({
+          deprecated: true,
+          description: 'Please use isUserAbleToCheckout instead.',
+        }),
+      ),
+      isUserAbleToCheckout: SchemaType.Optional(SchemaType.Boolean()),
+      'availableActions.checkout': SchemaType.Optional(
+        SchemaType.Boolean({
+          deprecated: true,
+          description: 'Please use isCheckoutActionAvailable instead.',
+        }),
+      ),
+      isCheckoutActionAvailable: SchemaType.Optional(SchemaType.Boolean()),
+      'availableActions.checkin': SchemaType.Optional(
+        SchemaType.Boolean({
+          deprecated: true,
+          description: 'Please use isCheckinActionAvailable instead.',
+        }),
+      ),
+      isCheckinActionAvailable: SchemaType.Optional(SchemaType.Boolean()),
+      'availableActions.update': SchemaType.Optional(
+        SchemaType.Boolean({
+          deprecated: true,
+          description: 'Please use isUpdateActionAvailable instead.',
+        }),
+      ),
+      isUpdateActionAvailable: SchemaType.Optional(SchemaType.Boolean()),
+      'availableActions.delete': SchemaType.Optional(
+        SchemaType.Boolean({
+          deprecated: true,
+          description: 'Please use isDeleteActionAvailable instead.',
+        }),
+      ),
+      isDeleteActionAvailable: SchemaType.Optional(SchemaType.Boolean()),
+    }),
+  });
+
+export const [LicenseEntityMetadata, createLicenseAssignEntity] =
+  createEntityMetadata({
+    resourceName: 'License',
+    _class: ['Application'],
+    _type: createEntityType('licensed_application'),
+    description: 'Snipe-IT License',
+    schema: SchemaType.Object({
+      licenseId: SchemaType.Optional(SchemaType.Number()),
+      company: SchemaType.Optional(SchemaType.String()),
+      'manufacturer.id': SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use manufacturerId instead.',
+        }),
+      ),
+      manufacturerId: SchemaType.Optional(SchemaType.Number()),
+      'manufacturer.name': SchemaType.Optional(
+        SchemaType.String({
+          deprecated: true,
+          description: 'Please use manufacturerName instead.',
+        }),
+      ),
+      manufacturerName: SchemaType.Optional(SchemaType.String()),
+      productKey: SchemaType.Optional(SchemaType.String()),
+      orderNumber: SchemaType.Optional(SchemaType.String()),
+      purchaseOrder: SchemaType.Optional(SchemaType.String()),
+      purchaseDate: SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use purchasedOn instead.',
+        }),
+      ),
+      purchasedOn: SchemaType.Optional(SchemaType.Number()),
+      terminationDate: SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use terminationOn instead.',
+        }),
+      ),
+      terminationOn: SchemaType.Optional(SchemaType.Number()),
+      depreciation: SchemaType.Optional(SchemaType.String()),
+      purchaseCost: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      notes: SchemaType.Optional(SchemaType.Array(SchemaType.String())),
+      expirationDate: SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use expirationOn instead.',
+        }),
+      ),
+      expirationOn: SchemaType.Optional(SchemaType.Number()),
+      seats: SchemaType.Optional(SchemaType.Number()),
+      freeSeatsCount: SchemaType.Optional(SchemaType.Number()),
+      licenseName: SchemaType.Optional(SchemaType.String()),
+      licenseEmail: SchemaType.Optional(SchemaType.String()),
+      reassignable: SchemaType.Optional(SchemaType.Boolean()),
+      maintained: SchemaType.Optional(SchemaType.Boolean()),
+      'supplier.id': SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use supplierId instead.',
+        }),
+      ),
+      supplierId: SchemaType.Optional(SchemaType.Number()),
+      'supplier.name': SchemaType.Optional(
+        SchemaType.String({
+          deprecated: true,
+          description: 'Please use supplierName instead.',
+        }),
+      ),
+      supplierName: SchemaType.Optional(SchemaType.String()),
+      'category.id': SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use categoryId instead.',
+        }),
+      ),
+      categoryId: SchemaType.Optional(SchemaType.Number()),
+      'category.name': SchemaType.Optional(
+        SchemaType.String({
+          deprecated: true,
+          description: 'Please use categoryName instead.',
+        }),
+      ),
+      categoryName: SchemaType.Optional(SchemaType.String()),
+      userCanCheckout: SchemaType.Optional(SchemaType.Boolean()),
+      'availableActions.checkout': SchemaType.Optional(
+        SchemaType.Boolean({
+          deprecated: true,
+          description: 'Please use availableActionsCheckout instead.',
+        }),
+      ),
+      availableActionsCheckout: SchemaType.Optional(SchemaType.Boolean()),
+      'availableActions.checkin': SchemaType.Optional(
+        SchemaType.Boolean({
+          deprecated: true,
+          description: 'Please use availableActionsCheckin instead.',
+        }),
+      ),
+      availableActionsCheckin: SchemaType.Optional(SchemaType.Boolean()),
+      'availableActions.update': SchemaType.Optional(
+        SchemaType.Boolean({
+          deprecated: true,
+          description: 'Please use availableActionsUpdate instead.',
+        }),
+      ),
+      availableActionsUpdate: SchemaType.Optional(SchemaType.Boolean()),
+      'availableActions.delete': SchemaType.Optional(
+        SchemaType.Boolean({
+          deprecated: true,
+          description: 'Please use availableActionsDelete instead.',
+        }),
+      ),
+      availableActionsDelete: SchemaType.Optional(SchemaType.Boolean()),
+    }),
+  });
+
+export const [UserEntityMetadata, createUserAssignEntity] =
+  createEntityMetadata({
+    resourceName: 'User',
+    _class: ['User'],
+    _type: createEntityType('user'),
+    description: 'Snipe-IT User',
+    schema: SchemaType.Object({
+      userId: SchemaType.Optional(SchemaType.Number()),
+      avatar: SchemaType.Optional(SchemaType.String()),
+      remote: SchemaType.Boolean(),
+      locale: SchemaType.Optional(SchemaType.String()),
+      employeeNum: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      'manager.id': SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use managerId instead.',
+        }),
+      ),
+      managerId: SchemaType.Optional(SchemaType.Number()),
+      'manager.name': SchemaType.Optional(
+        SchemaType.String({
+          deprecated: true,
+          description: 'Please use managerName instead.',
+        }),
+      ),
+      managerName: SchemaType.Optional(SchemaType.String()),
+      jobtitle: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      phone: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      website: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      address: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      city: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      state: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      country: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      zip: SchemaType.Optional(
+        SchemaType.Union([SchemaType.String(), SchemaType.Null()]),
+      ),
+      email: SchemaType.Optional(
+        SchemaType.String({
+          format: 'email',
+        }),
+      ),
+      'department.id': SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use departmentId instead.',
+        }),
+      ),
+      departmentId: SchemaType.Optional(SchemaType.Number()),
+      'department.name': SchemaType.Optional(
+        SchemaType.String({
+          deprecated: true,
+          description: 'Please use departmentName instead.',
+        }),
+      ),
+      departmentName: SchemaType.Optional(SchemaType.String()),
+      'location.id': SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use locationId instead.',
+        }),
+      ),
+      locationId: SchemaType.Optional(SchemaType.Number()),
+      'location.name': SchemaType.Optional(
+        SchemaType.String({
+          deprecated: true,
+          description: 'Please use locationName instead.',
+        }),
+      ),
+      locationName: SchemaType.Optional(SchemaType.String()),
+      ldapImport: SchemaType.Optional(
+        SchemaType.Boolean({
+          deprecated: true,
+          description: 'Please use isLdapImport instead.',
+        }),
+      ),
+      isLdapImport: SchemaType.Optional(SchemaType.Boolean()),
+      twoFactorEnrolled: SchemaType.Boolean(),
+      assetsCount: SchemaType.Optional(SchemaType.Number()),
+      licensesCount: SchemaType.Optional(SchemaType.Number()),
+      accessoriesCount: SchemaType.Optional(SchemaType.Number()),
+      consumablesCount: SchemaType.Optional(SchemaType.Number()),
+      'company.id': SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use companyId instead.',
+        }),
+      ),
+      companyId: SchemaType.Optional(SchemaType.Number()),
+      'company.name': SchemaType.Optional(
+        SchemaType.String({
+          deprecated: true,
+          description: 'Please use companyName instead.',
+        }),
+      ),
+      companyName: SchemaType.Optional(SchemaType.String()),
+      'createdBy.id': SchemaType.Optional(
+        SchemaType.Number({
+          deprecated: true,
+          description: 'Please use createdById instead.',
+        }),
+      ),
+      createdById: SchemaType.Optional(SchemaType.Number()),
+      'createdBy.name': SchemaType.Optional(
+        SchemaType.String({
+          deprecated: true,
+          description: 'Please use createdByName instead.',
+        }),
+      ),
+      createdByName: SchemaType.Optional(SchemaType.String()),
+      lastLogin: SchemaType.Optional(SchemaType.Number()),
+      deletedAt: SchemaType.Optional(SchemaType.Number()),
+    }),
+  });
+
+export const [PersonEntityMetadata, createPersonAssignEntity] =
+  createEntityMetadata({
+    resourceName: 'Person',
+    _class: ['Person'],
+    _type: createEntityType('person'),
+    description: 'Snipe-IT Person',
+    schema: SchemaType.Object({
+      name: SchemaType.String(),
+    }),
+  });
diff --git a/src/helpers.ts b/src/helpers.ts
new file mode 100644
index 0000000..040222b
--- /dev/null
+++ b/src/helpers.ts
@@ -0,0 +1,8 @@
+import { createIntegrationHelpers } from '@jupiterone/integration-sdk-core';
+import { typeboxClassSchemaMap } from '@jupiterone/data-model';
+
+export const { createEntityType, createEntityMetadata } =
+  createIntegrationHelpers({
+    integrationName: 'snipeit',
+    classSchemaMap: typeboxClassSchemaMap,
+  });
diff --git a/src/steps/constants.ts b/src/steps/constants.ts
index 9d437b2..596fca1 100644
--- a/src/steps/constants.ts
+++ b/src/steps/constants.ts
@@ -5,6 +5,16 @@ import {
   StepMappedRelationshipMetadata,
   StepRelationshipMetadata,
 } from '@jupiterone/integration-sdk-core';
+import {
+  AccountEntityMetadata,
+  ConsumableEntityMetadata,
+  HardwareEntityMetadata,
+  LicenseEntityMetadata,
+  LocationEntityMetadata,
+  PersonEntityMetadata,
+  ServiceEntityMetadata,
+  UserEntityMetadata,
+} from '../entities';
 
 export const ACCOUNT_ENTITY_KEY = 'entity:account';
 
@@ -29,46 +39,14 @@ export const Entities: Record<
   | 'PERSON',
   StepEntityMetadata
 > = {
-  ACCOUNT: {
-    resourceName: 'Account',
-    _type: 'snipeit_account',
-    _class: ['Account'],
-  },
-  SERVICE: {
-    resourceName: 'Service',
-    _type: 'snipeit_service',
-    _class: ['Service'],
-  },
-  LOCATION: {
-    resourceName: 'Location',
-    _type: 'location',
-    _class: ['Site'],
-  },
-  HARDWARE: {
-    resourceName: 'Hardware',
-    _type: 'snipeit_hardware',
-    _class: ['Device'],
-  },
-  CONSUMABLE: {
-    resourceName: 'Consumable',
-    _type: 'snipeit_consumable_resource',
-    _class: ['Resource'],
-  },
-  LICENSE: {
-    resourceName: 'License',
-    _type: 'snipeit_licensed_application',
-    _class: ['Application'],
-  },
-  USER: {
-    resourceName: 'User',
-    _type: 'snipeit_user',
-    _class: ['User'],
-  },
-  PERSON: {
-    resourceName: 'Person',
-    _type: 'person',
-    _class: ['Person'],
-  },
+  ACCOUNT: AccountEntityMetadata,
+  SERVICE: ServiceEntityMetadata,
+  LOCATION: LocationEntityMetadata,
+  HARDWARE: HardwareEntityMetadata,
+  CONSUMABLE: ConsumableEntityMetadata,
+  LICENSE: LicenseEntityMetadata,
+  USER: UserEntityMetadata,
+  PERSON: PersonEntityMetadata,
 };
 
 export const Relationships: Record<
diff --git a/src/steps/fetch-account/converter.ts b/src/steps/fetch-account/converter.ts
index ef32b49..38fdcc1 100644
--- a/src/steps/fetch-account/converter.ts
+++ b/src/steps/fetch-account/converter.ts
@@ -1,11 +1,14 @@
 import {
   Entity,
   createIntegrationEntity,
-  convertProperties,
   parseTimePropertyValue,
 } from '@jupiterone/integration-sdk-core';
 import { Location } from '../../collector';
-import { Entities } from '../constants';
+import {
+  createAccountAssignEntity,
+  createLocationAssignEntity,
+  createServiceAssignEntity,
+} from '../../entities';
 
 export function getAccountKey(id: string): string {
   return `snipeit_account:${id}`;
@@ -20,27 +23,24 @@ export function getLocationKey(id: number): string {
 }
 
 export function getAccountEntity(instance: any): Entity {
-  return {
+  return createAccountAssignEntity({
     _key: getAccountKey(instance.id),
-    _type: Entities.ACCOUNT._type,
-    _class: Entities.ACCOUNT._class,
     name: instance.name,
     displayName: instance.name,
     description: instance.description,
-  };
+    vendor: 'Snipe-IT',
+  });
 }
 
 export function getServiceEntity(instance: any): Entity {
-  return {
+  return createServiceAssignEntity({
     _key: getServiceKey(instance.id),
-    _type: Entities.SERVICE._type,
-    _class: Entities.SERVICE._class,
     name: 'Snipe-IT ITAM',
     displayName: 'Snipe-IT ITAM',
     description: 'IT Asset Management (ITAM)',
     category: ['infrastructure'],
     function: ['ITAM'],
-  };
+  });
 }
 
 export function convertLocation(
@@ -49,17 +49,30 @@ export function convertLocation(
   return createIntegrationEntity({
     entityData: {
       source: data,
-      assign: {
-        ...convertProperties(data),
+      assign: createLocationAssignEntity({
         _key: getLocationKey(data.id),
-        _type: Entities.LOCATION._type,
-        _class: Entities.LOCATION._class,
         id: getLocationKey(data.id),
-        locationId: data.id,
         displayName: data.name,
+        name: data.name,
+        locationId: data.id,
+        image: data.image,
+        address: data.address,
+        address2: data.address2,
+        city: data.city,
+        state: data.state,
+        country: data.country,
+        zip: data.zip,
+        assignedAssetsCount: data.assigned_assets_count,
+        assetsCount: data.assets_count,
+        rtdAssetsCount: data.rtd_assets_count,
+        usersCount: data.users_count,
+        currency: data.currency,
+        isUpdateActionAvailable: Boolean(data.available_actions?.update),
+        isDeleteActionAvailable: Boolean(data.available_actions?.delete),
+        isCloneActionAvailable: Boolean(data.available_actions?.clone),
         createdOn: parseTimePropertyValue(data.created_at?.datetime),
         updatedOn: parseTimePropertyValue(data.updated_at?.datetime),
-      },
+      }),
     },
   });
 }
diff --git a/src/steps/fetch-consumables/converter.ts b/src/steps/fetch-consumables/converter.ts
index c3e433a..8cff95c 100644
--- a/src/steps/fetch-consumables/converter.ts
+++ b/src/steps/fetch-consumables/converter.ts
@@ -3,7 +3,7 @@ import {
   parseTimePropertyValue,
 } from '@jupiterone/integration-sdk-core';
 import { SnipeItConsumable } from '../../collector';
-import { Entities } from '../constants';
+import { createConsumableAssignEntity } from '../../entities';
 
 export function getConsumableKey(id: number): string {
   return `snipeit_consumable_resource:${id}`;
@@ -15,39 +15,52 @@ export function convertConsumable(
   return createIntegrationEntity({
     entityData: {
       source: data,
-      assign: {
+      assign: createConsumableAssignEntity({
         _key: getConsumableKey(data.id),
-        _type: Entities.CONSUMABLE._type,
-        _class: Entities.CONSUMABLE._class,
         id: getConsumableKey(data.id),
         consumableId: data.id,
         displayName: data.name,
+        name: data.name,
         image: data.image,
         'category.id': data.category?.id,
+        categoryId: data.category?.id,
         'category.name': data.category?.name,
+        categoryName: data.category?.name,
         'company.id': data.company?.id,
+        companyId: data.company?.id,
         'company.name': data.company?.name,
+        companyName: data.company?.name,
         itemNo: data.item_no,
         'location.id': data.location?.id,
+        locationId: data.location?.id,
         'location.name': data.location?.name,
+        locationName: data.location?.name,
         'manufacturer.id': data.manufacturer?.id,
+        manufacturerId: data.manufacturer?.id,
         'manufacturer.name': data.manufacturer?.name,
+        manufacturerName: data.manufacturer?.name,
         minAmt: data.min_amt,
         modelNumber: data.model_number,
         remaining: data.remaining,
         orderNumber: data.order_number,
         purchaseCost: data.purchase_cost,
         purchaseDate: parseTimePropertyValue(data.purchase_date?.datetime),
+        purchasedOn: parseTimePropertyValue(data.purchase_date?.datetime),
         qty: data.qty,
         notes: data.notes ? [data.notes] : undefined,
         createdOn: parseTimePropertyValue(data.created_at?.datetime),
         updatedOn: parseTimePropertyValue(data.updated_at?.datetime),
         userCanCheckout: data.user_can_checkout,
+        isUserAbleToCheckout: data.user_can_checkout,
         'availableActions.checkout': data.available_actions?.checkout,
+        isCheckoutActionAvailable: data.available_actions?.checkout,
         'availableActions.checkin': data.available_actions?.checkin,
+        isCheckinActionAvailable: data.available_actions?.checkin,
         'availableActions.update': data.available_actions?.update,
+        isUpdateActionAvailable: data.available_actions?.update,
         'availableActions.delete': data.available_actions?.delete,
-      },
+        isDeleteActionAvailable: data.available_actions?.delete,
+      }),
     },
   });
 }
diff --git a/src/steps/fetch-hardware/converter.ts b/src/steps/fetch-hardware/converter.ts
index 10a7352..30cd1ba 100644
--- a/src/steps/fetch-hardware/converter.ts
+++ b/src/steps/fetch-hardware/converter.ts
@@ -10,6 +10,7 @@ import {
 import { SnipeItHardware } from '../../collector';
 import { Entities, MappedRelationships } from '../constants';
 import { getLocationKey } from '../fetch-account/converter';
+import { createHardwareAssignEntity } from '../../entities';
 
 export function getHardwareKey(id: number): string {
   return `snipeit_hardware:${id}`;
@@ -34,10 +35,8 @@ export function convertHardware(
   return createIntegrationEntity({
     entityData: {
       source: data,
-      assign: {
+      assign: createHardwareAssignEntity({
         _key: hardwareKey,
-        _type: Entities.HARDWARE._type,
-        _class: Entities.HARDWARE._class,
         id: String(hardwareId),
         deviceId: String(hardwareId),
         name: data.name,
@@ -51,7 +50,8 @@ export function convertHardware(
         model: data.model?.name ?? null,
         serial: data.serial,
         byod: data.byod,
-        cost: Number(data.purchase_cost),
+        BYOD: data.byod,
+        cost: Number(data.purchase_cost) || undefined,
         supplier: data.supplier?.name,
         EOL: !!data.eol,
         status:
@@ -59,19 +59,21 @@ export function convertHardware(
             ? 'ready'
             : data.status_label?.name?.match(/broken/i)
               ? 'defective'
-              : data.status_label?.status_meta,
+              : (data.status_label?.status_meta as any), // TODO: Should match Device _class defined status options
         notes: data.notes ? [data.notes] : undefined,
         location: data.location?.name,
         locationId: data.location?.id,
         createdOn: parseTimePropertyValue(data.created_at?.datetime),
         updatedOn: parseTimePropertyValue(data.updated_at?.datetime),
-        lastSeenOn: [
-          parseTimePropertyValue(data.last_checkout?.datetime),
-          parseTimePropertyValue(data.updated_at?.datetime),
-        ].sort()[0],
+        lastSeenOn:
+          [
+            parseTimePropertyValue(data.last_checkout?.datetime),
+            parseTimePropertyValue(data.updated_at?.datetime),
+          ].sort()[0] ?? null,
         statusMeta: data.status_label.status_meta,
         statusName: data.status_label.name,
-      },
+        purchaseCost: data.purchase_cost,
+      }),
     },
   });
 }
diff --git a/src/steps/fetch-licenses/converter.ts b/src/steps/fetch-licenses/converter.ts
index fcb9d64..e9305ee 100644
--- a/src/steps/fetch-licenses/converter.ts
+++ b/src/steps/fetch-licenses/converter.ts
@@ -3,7 +3,7 @@ import {
   parseTimePropertyValue,
 } from '@jupiterone/integration-sdk-core';
 import { HardwareLicense } from '../../collector';
-import { Entities } from '../constants';
+import { createLicenseAssignEntity } from '../../entities';
 
 export function getLicenseKey(id: string): string {
   return `snipeit_licensed_application:${id}`;
@@ -15,27 +15,31 @@ export function convertLicense(
   return createIntegrationEntity({
     entityData: {
       source: data,
-      assign: {
+      assign: createLicenseAssignEntity({
         _key: getLicenseKey(String(data.id)),
-        _type: Entities.LICENSE._type,
-        _class: Entities.LICENSE._class,
         id: getLicenseKey(String(data.id)),
         licenseId: data.id,
         displayName: data.name,
+        name: data.name,
         company: data.company?.name,
         'manufacturer.id': data.manufacturer?.id,
+        manufacturerId: data.manufacturer?.id,
         'manufacturer.name': data.manufacturer?.name,
+        manufacturerName: data.manufacturer?.name,
         productKey: data.product_key,
         orderNumber: data.order_number,
         purchaseOrder: data.purchase_order,
         purchaseDate: parseTimePropertyValue(data.purchase_date?.datetime),
+        purchasedOn: parseTimePropertyValue(data.purchase_date?.datetime),
         terminationDate: parseTimePropertyValue(
           data.termination_date?.datetime,
         ),
+        terminationOn: parseTimePropertyValue(data.termination_date?.datetime),
         depreciation: data.depreciation?.name,
         purchaseCost: data.purchase_cost_numeric ?? data.purchase_cost,
         notes: data.notes ? [data.notes] : undefined,
         expirationDate: parseTimePropertyValue(data.expiration_date?.datetime),
+        expirationOn: parseTimePropertyValue(data.expiration_date?.datetime),
         seats: data.seats,
         freeSeatsCount: data.free_seats_count,
         licenseName: data.license_name,
@@ -43,17 +47,25 @@ export function convertLicense(
         reassignable: data.reassignable,
         maintained: data.maintained,
         'supplier.id': data.supplier?.id,
+        supplierId: data.supplier?.id,
         'supplier.name': data.supplier?.name,
+        supplierName: data.supplier?.name,
         'category.id': data.category?.id,
+        categoryId: data.category?.id,
         'category.name': data.category?.name,
+        categoryName: data.category?.name,
         createdOn: parseTimePropertyValue(data.created_at?.datetime),
         updatedOn: parseTimePropertyValue(data.updated_at?.datetime),
         userCanCheckout: data.user_can_checkout,
         'availableActions.checkout': data.available_actions?.checkout,
+        availableActionsCheckout: data.available_actions?.checkout,
         'availableActions.checkin': data.available_actions?.checkin,
+        availableActionsCheckin: data.available_actions?.checkin,
         'availableActions.update': data.available_actions?.update,
+        availableActionsUpdate: data.available_actions?.update,
         'availableActions.delete': data.available_actions?.delete,
-      },
+        availableActionsDelete: data.available_actions?.delete,
+      }),
     },
   });
 }
diff --git a/src/steps/fetch-users/converter.ts b/src/steps/fetch-users/converter.ts
index 059c109..29f6f8a 100644
--- a/src/steps/fetch-users/converter.ts
+++ b/src/steps/fetch-users/converter.ts
@@ -8,6 +8,7 @@ import {
 } from '@jupiterone/integration-sdk-core';
 import { SnipeItUser } from '../../collector';
 import { Entities, MappedRelationships } from '../constants';
+import { createUserAssignEntity } from '../../entities';
 
 export function getUserKey(id: string): string {
   return `snipeit_user:${id}`;
@@ -23,22 +24,23 @@ export function convertUser(
   return createIntegrationEntity({
     entityData: {
       source: data,
-      assign: {
+      assign: createUserAssignEntity({
         _key: getUserKey(String(data.id)),
-        _type: Entities.USER._type,
-        _class: Entities.USER._class,
         id: getUserKey(String(data.id)),
         userId: data.id,
         displayName: data.name,
+        name: data.name,
         avatar: data.avatar,
         firstName: data.first_name,
         lastName: data.last_name,
         username: data.username,
-        remote: data.remote,
+        remote: Boolean(data.remote),
         locale: data.locale,
         employeeNum: data.employee_num,
         'manager.id': data.manager?.id,
+        managerId: data.manager?.id,
         'manager.name': data.manager?.name,
+        managerName: data.manager?.name,
         jobtitle: data.jobtitle,
         phone: data.phone,
         website: data.website,
@@ -47,15 +49,20 @@ export function convertUser(
         state: data.state,
         country: data.country,
         zip: data.zip,
-        ...(data.email && { email: data.email }),
-        ...(emailDomain && { emailDomain: [emailDomain] }),
-        ...(shortLoginId && { shortLoginId }),
+        email: data.email,
+        emailDomain: emailDomain ? [emailDomain] : undefined,
+        shortLoginId: shortLoginId,
         'department.id': data.department?.id,
+        departmentId: data.department?.id,
         'department.name': data.department?.name,
+        departmentName: data.department?.name,
         'location.id': data.location?.id,
+        locationId: data.location?.id,
         'location.name': data.location?.name,
+        locationName: data.location?.name,
         notes: data.notes ? [data.notes] : undefined,
         ...(data.permissions && {
+          // TODO: Replace all dot separated properties with camelCased
           'permissions.superuser': data.permissions.superuser,
           'permissions.admin': data.permissions.admin,
           'permissions.import': data.permissions.import,
@@ -182,21 +189,26 @@ export function convertUser(
         }),
         active: data.activated,
         ldapImport: data.ldap_import,
-        mfaEnabled: Boolean(data.two_factor_activated),
-        twoFactorEnrolled: data.two_factor_enrolled,
+        isLdapImport: data.ldap_import,
+        mfaEnabled: data.two_factor_activated,
+        twoFactorEnrolled: Boolean(data.two_factor_enrolled),
         assetsCount: data.assets_count,
         licensesCount: data.licenses_count,
         accessoriesCount: data.accessories_count,
         consumablesCount: data.consumables_count,
         'company.id': data.company?.id,
+        companyId: data.company?.id,
         'company.name': data.company?.name,
+        companyName: data.company?.name,
         'createdBy.id': data.created_by?.id,
+        createdById: data.created_by?.id,
         'createdBy.name': data.created_by?.name,
+        createdByName: data.created_by?.name,
         createdOn: parseTimePropertyValue(data.created_at?.datetime),
         updatedOn: parseTimePropertyValue(data.updated_at?.datetime),
         lastLogin: parseTimePropertyValue(data.last_login?.datetime),
         deletedAt: parseTimePropertyValue(data.deleted_at?.datetime),
-      },
+      }),
     },
   });
 }