@thunkier/thunkmetrc-wrapper 0.2.2 → 0.3.1

package/dist/wrapper/src/Factory.d.ts

@@ -0,0 +1,13 @@
+import { type Logger } from '@thunkier/thunkmetrc-client';
+import { MetrcWrapper } from './index';
+export interface MetrcFactoryConfig {
+    maxConcurrentRequests?: number;
+    logger?: Logger;
+    timeout?: number;
+}
+export declare class MetrcFactory {
+    private config;
+    private sharedLimiter;
+    constructor(config?: MetrcFactoryConfig);
+    create(baseUrl: string, vendorKey: string, userKey: string): MetrcWrapper;
+}

package/dist/wrapper/src/Factory.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetrcFactory = void 0;
+const thunkmetrc_client_1 = require("@thunkier/thunkmetrc-client");
+const index_1 = require("./index");
+const RateLimiter_1 = require("./RateLimiter");
+class MetrcFactory {
+    constructor(config = {}) {
+        this.config = config;
+        const limConfig = new RateLimiter_1.RateLimiterConfig();
+        if (config.maxConcurrentRequests) {
+            limConfig.maxConcurrentGetIntegrator = config.maxConcurrentRequests;
+        }
+        this.sharedLimiter = new RateLimiter_1.MetrcRateLimiter(limConfig);
+    }
+    create(baseUrl, vendorKey, userKey) {
+        const client = new thunkmetrc_client_1.MetrcClient({
+            baseUrl,
+            vendorKey,
+            userKey,
+            timeout: this.config.timeout,
+            logger: this.config.logger
+        });
+        return new index_1.MetrcWrapper(client, this.sharedLimiter);
+    }
+}
+exports.MetrcFactory = MetrcFactory;

package/dist/{RateLimiter.js → wrapper/src/RateLimiter.js}

@@ -96,28 +96,51 @@ class MetrcRateLimiter {
         if (facility) {
             await this.getFacilityRate(facility).wait();
         }
-        // Retry loop
-        while (true) {
+        const maxRetries = 10;
+        const initialBackoffMs = 1000;
+        const maxBackoffMs = 60000;
+        const backoffExponent = 2;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
             try {
                 return await op();
             }
             catch (err) {
-                // Check for 429
-                if (err?.response?.status === 429 || (err?.message && err.message.includes('429'))) {
-                    // Backoff
+                // Check for 429 or 5xx
+                const status = err?.response?.status;
+                const is429 = status === 429 || (err?.message && err.message.includes('429'));
+                const is5xx = status >= 500 && status < 600;
+                if (!is429 && !is5xx) {
+                    throw err;
+                }
+                if (attempt === maxRetries) {
+                    throw err;
+                }
+                let waitMs = 0;
+                if (is429) {
+                    // Respect Retry-After
                     const retryAfterInfo = err?.response?.headers?.['retry-after'];
-                    let waitMs = 1000;
                     if (retryAfterInfo) {
                         const seconds = parseInt(retryAfterInfo, 10);
-                        if (!isNaN(seconds))
+                        if (!isNaN(seconds)) {
                             waitMs = seconds * 1000;
+                        }
                     }
-                    await new Promise(resolve => setTimeout(resolve, waitMs));
-                    continue;
                 }
-                throw err;
+                // If no Retry-After or 5xx, use Jittered Exponential Backoff
+                if (waitMs === 0) {
+                    const exponential = initialBackoffMs * Math.pow(backoffExponent, attempt);
+                    const capped = Math.min(exponential, maxBackoffMs);
+                    // Full Jitter: random between 0 and capped
+                    // Or Proportional Jitter: capped + random(0-20%)?
+                    // "Decorrelated Jitter" is often best, but Simple Full Jitter is standard.
+                    // Let's use Proportional Jitter to match C# logic (base + 0-20% jitter)
+                    const jitter = Math.random() * 0.2 * capped;
+                    waitMs = capped + jitter;
+                }
+                await new Promise(resolve => setTimeout(resolve, waitMs));
             }
         }
+        throw new Error("Max retries exceeded");
     }
     getFacilityRate(facility) {
         let tb = this.facilityRates.get(facility);

package/dist/wrapper/src/Utils.d.ts

@@ -0,0 +1,3 @@
+import { PaginatedResponse } from './models';
+export declare function iteratePages<T>(fetchPage: (page: number) => Promise<PaginatedResponse<T> | T[] | null>): AsyncGenerator<T, void, unknown>;
+export declare function parallelSync<T>(targets: any[], concurrencyLimit: number, operation: (target: any) => Promise<T[]>): Promise<Record<string, T[]>>;

package/dist/wrapper/src/Utils.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iteratePages = iteratePages;
+exports.parallelSync = parallelSync;
+async function* iteratePages(fetchPage) {
+    let page = 1;
+    while (true) {
+        const response = await fetchPage(page);
+        if (!response) {
+            break;
+        }
+        let items = [];
+        let totalPages;
+        if (Array.isArray(response)) {
+            items = response;
+            totalPages = 1;
+        }
+        else {
+            // Check if it has Data property (PaginatedResponse)
+            const paginated = response; // Cast to access optional props safely
+            if (paginated.Data && Array.isArray(paginated.Data)) {
+                items = paginated.Data;
+                totalPages = paginated.TotalPages;
+            }
+            else if (Array.isArray(paginated)) {
+                // Fallback if type overlap issues
+                items = paginated;
+            }
+        }
+        if (items.length === 0) {
+            break;
+        }
+        for (const item of items) {
+            yield item;
+        }
+        if (typeof totalPages === 'number' && page >= totalPages) {
+            break;
+        }
+        // Safety break if we assume 1 page for raw arrays
+        if (totalPages === 1) {
+            break;
+        }
+        page++;
+    }
+}
+async function parallelSync(targets, concurrencyLimit, operation) {
+    const results = {};
+    const queue = [...targets];
+    // Simple semaphore-like worker pool
+    const workers = Array(Math.min(concurrencyLimit, targets.length)).fill(null).map(async () => {
+        while (queue.length > 0) {
+            const target = queue.shift();
+            if (!target)
+                break;
+            try {
+                const items = await operation(target);
+                const lic = target.licenseNumber || target.license || String(target);
+                results[lic] = items;
+            }
+            catch (e) {
+                console.error(`Error processing target ${target}:`, e);
+            }
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}

package/dist/wrapper/src/index.d.ts

@@ -0,0 +1,87 @@
+export * from '@thunkier/thunkmetrc-client';
+import { MetrcClient as InternalMetrcClient } from '@thunkier/thunkmetrc-client';
+import { MetrcRateLimiter, RateLimiterConfig } from './RateLimiter';
+export * from './models';
+export * from './services/AdditivesTemplatesService';
+import { AdditivesTemplatesService } from './services/AdditivesTemplatesService';
+export * from './services/CaregiversStatusService';
+import { CaregiversStatusService } from './services/CaregiversStatusService';
+export * from './services/EmployeesService';
+import { EmployeesService } from './services/EmployeesService';
+export * from './services/FacilitiesService';
+import { FacilitiesService } from './services/FacilitiesService';
+export * from './services/HarvestsService';
+import { HarvestsService } from './services/HarvestsService';
+export * from './services/ItemsService';
+import { ItemsService } from './services/ItemsService';
+export * from './services/LabTestsService';
+import { LabTestsService } from './services/LabTestsService';
+export * from './services/LocationsService';
+import { LocationsService } from './services/LocationsService';
+export * from './services/PackagesService';
+import { PackagesService } from './services/PackagesService';
+export * from './services/PatientCheckInsService';
+import { PatientCheckInsService } from './services/PatientCheckInsService';
+export * from './services/PatientsService';
+import { PatientsService } from './services/PatientsService';
+export * from './services/PatientsStatusService';
+import { PatientsStatusService } from './services/PatientsStatusService';
+export * from './services/PlantBatchesService';
+import { PlantBatchesService } from './services/PlantBatchesService';
+export * from './services/PlantsService';
+import { PlantsService } from './services/PlantsService';
+export * from './services/ProcessingJobService';
+import { ProcessingJobService } from './services/ProcessingJobService';
+export * from './services/RetailIdService';
+import { RetailIdService } from './services/RetailIdService';
+export * from './services/SalesService';
+import { SalesService } from './services/SalesService';
+export * from './services/SandboxService';
+import { SandboxService } from './services/SandboxService';
+export * from './services/StrainsService';
+import { StrainsService } from './services/StrainsService';
+export * from './services/SublocationsService';
+import { SublocationsService } from './services/SublocationsService';
+export * from './services/TagsService';
+import { TagsService } from './services/TagsService';
+export * from './services/TransfersService';
+import { TransfersService } from './services/TransfersService';
+export * from './services/TransportersService';
+import { TransportersService } from './services/TransportersService';
+export * from './services/UnitsOfMeasureService';
+import { UnitsOfMeasureService } from './services/UnitsOfMeasureService';
+export * from './services/WasteMethodsService';
+import { WasteMethodsService } from './services/WasteMethodsService';
+export * from './services/WebhooksService';
+import { WebhooksService } from './services/WebhooksService';
+export declare class MetrcWrapper {
+    client: InternalMetrcClient;
+    private rateLimiter;
+    additivesTemplates: AdditivesTemplatesService;
+    caregiversStatus: CaregiversStatusService;
+    employees: EmployeesService;
+    facilities: FacilitiesService;
+    harvests: HarvestsService;
+    items: ItemsService;
+    labTests: LabTestsService;
+    locations: LocationsService;
+    packages: PackagesService;
+    patientCheckIns: PatientCheckInsService;
+    patients: PatientsService;
+    patientsStatus: PatientsStatusService;
+    plantBatches: PlantBatchesService;
+    plants: PlantsService;
+    processingJob: ProcessingJobService;
+    retailId: RetailIdService;
+    sales: SalesService;
+    sandbox: SandboxService;
+    strains: StrainsService;
+    sublocations: SublocationsService;
+    tags: TagsService;
+    transfers: TransfersService;
+    transporters: TransportersService;
+    unitsOfMeasure: UnitsOfMeasureService;
+    wasteMethods: WasteMethodsService;
+    webhooks: WebhooksService;
+    constructor(client: InternalMetrcClient, configOrLimiter?: RateLimiterConfig | MetrcRateLimiter);
+}

package/dist/wrapper/src/index.js

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetrcWrapper = void 0;
+__exportStar(require("@thunkier/thunkmetrc-client"), exports);
+const RateLimiter_1 = require("./RateLimiter");
+__exportStar(require("./models"), exports);
+__exportStar(require("./services/AdditivesTemplatesService"), exports);
+const AdditivesTemplatesService_1 = require("./services/AdditivesTemplatesService");
+__exportStar(require("./services/CaregiversStatusService"), exports);
+const CaregiversStatusService_1 = require("./services/CaregiversStatusService");
+__exportStar(require("./services/EmployeesService"), exports);
+const EmployeesService_1 = require("./services/EmployeesService");
+__exportStar(require("./services/FacilitiesService"), exports);
+const FacilitiesService_1 = require("./services/FacilitiesService");
+__exportStar(require("./services/HarvestsService"), exports);
+const HarvestsService_1 = require("./services/HarvestsService");
+__exportStar(require("./services/ItemsService"), exports);
+const ItemsService_1 = require("./services/ItemsService");
+__exportStar(require("./services/LabTestsService"), exports);
+const LabTestsService_1 = require("./services/LabTestsService");
+__exportStar(require("./services/LocationsService"), exports);
+const LocationsService_1 = require("./services/LocationsService");
+__exportStar(require("./services/PackagesService"), exports);
+const PackagesService_1 = require("./services/PackagesService");
+__exportStar(require("./services/PatientCheckInsService"), exports);
+const PatientCheckInsService_1 = require("./services/PatientCheckInsService");
+__exportStar(require("./services/PatientsService"), exports);
+const PatientsService_1 = require("./services/PatientsService");
+__exportStar(require("./services/PatientsStatusService"), exports);
+const PatientsStatusService_1 = require("./services/PatientsStatusService");
+__exportStar(require("./services/PlantBatchesService"), exports);
+const PlantBatchesService_1 = require("./services/PlantBatchesService");
+__exportStar(require("./services/PlantsService"), exports);
+const PlantsService_1 = require("./services/PlantsService");
+__exportStar(require("./services/ProcessingJobService"), exports);
+const ProcessingJobService_1 = require("./services/ProcessingJobService");
+__exportStar(require("./services/RetailIdService"), exports);
+const RetailIdService_1 = require("./services/RetailIdService");
+__exportStar(require("./services/SalesService"), exports);
+const SalesService_1 = require("./services/SalesService");
+__exportStar(require("./services/SandboxService"), exports);
+const SandboxService_1 = require("./services/SandboxService");
+__exportStar(require("./services/StrainsService"), exports);
+const StrainsService_1 = require("./services/StrainsService");
+__exportStar(require("./services/SublocationsService"), exports);
+const SublocationsService_1 = require("./services/SublocationsService");
+__exportStar(require("./services/TagsService"), exports);
+const TagsService_1 = require("./services/TagsService");
+__exportStar(require("./services/TransfersService"), exports);
+const TransfersService_1 = require("./services/TransfersService");
+__exportStar(require("./services/TransportersService"), exports);
+const TransportersService_1 = require("./services/TransportersService");
+__exportStar(require("./services/UnitsOfMeasureService"), exports);
+const UnitsOfMeasureService_1 = require("./services/UnitsOfMeasureService");
+__exportStar(require("./services/WasteMethodsService"), exports);
+const WasteMethodsService_1 = require("./services/WasteMethodsService");
+__exportStar(require("./services/WebhooksService"), exports);
+const WebhooksService_1 = require("./services/WebhooksService");
+class MetrcWrapper {
+    constructor(client, configOrLimiter) {
+        this.client = client;
+        if (configOrLimiter instanceof RateLimiter_1.MetrcRateLimiter) {
+            this.rateLimiter = configOrLimiter;
+        }
+        else {
+            this.rateLimiter = new RateLimiter_1.MetrcRateLimiter(configOrLimiter);
+        }
+        this.additivesTemplates = new AdditivesTemplatesService_1.AdditivesTemplatesService(client, this.rateLimiter);
+        this.caregiversStatus = new CaregiversStatusService_1.CaregiversStatusService(client, this.rateLimiter);
+        this.employees = new EmployeesService_1.EmployeesService(client, this.rateLimiter);
+        this.facilities = new FacilitiesService_1.FacilitiesService(client, this.rateLimiter);
+        this.harvests = new HarvestsService_1.HarvestsService(client, this.rateLimiter);
+        this.items = new ItemsService_1.ItemsService(client, this.rateLimiter);
+        this.labTests = new LabTestsService_1.LabTestsService(client, this.rateLimiter);
+        this.locations = new LocationsService_1.LocationsService(client, this.rateLimiter);
+        this.packages = new PackagesService_1.PackagesService(client, this.rateLimiter);
+        this.patientCheckIns = new PatientCheckInsService_1.PatientCheckInsService(client, this.rateLimiter);
+        this.patients = new PatientsService_1.PatientsService(client, this.rateLimiter);
+        this.patientsStatus = new PatientsStatusService_1.PatientsStatusService(client, this.rateLimiter);
+        this.plantBatches = new PlantBatchesService_1.PlantBatchesService(client, this.rateLimiter);
+        this.plants = new PlantsService_1.PlantsService(client, this.rateLimiter);
+        this.processingJob = new ProcessingJobService_1.ProcessingJobService(client, this.rateLimiter);
+        this.retailId = new RetailIdService_1.RetailIdService(client, this.rateLimiter);
+        this.sales = new SalesService_1.SalesService(client, this.rateLimiter);
+        this.sandbox = new SandboxService_1.SandboxService(client, this.rateLimiter);
+        this.strains = new StrainsService_1.StrainsService(client, this.rateLimiter);
+        this.sublocations = new SublocationsService_1.SublocationsService(client, this.rateLimiter);
+        this.tags = new TagsService_1.TagsService(client, this.rateLimiter);
+        this.transfers = new TransfersService_1.TransfersService(client, this.rateLimiter);
+        this.transporters = new TransportersService_1.TransportersService(client, this.rateLimiter);
+        this.unitsOfMeasure = new UnitsOfMeasureService_1.UnitsOfMeasureService(client, this.rateLimiter);
+        this.wasteMethods = new WasteMethodsService_1.WasteMethodsService(client, this.rateLimiter);
+        this.webhooks = new WebhooksService_1.WebhooksService(client, this.rateLimiter);
+    }
+}
+exports.MetrcWrapper = MetrcWrapper;

package/dist/wrapper/src/models/ActiveDeliveriesRetailer.d.ts

@@ -0,0 +1,32 @@
+export interface ActiveDeliveriesRetailer {
+    AcceptedDateTime?: string;
+    ActualDepartureDateTime?: string;
+    AllowFullEdit?: boolean;
+    CompletedDateTime?: string;
+    DateTime?: string;
+    Destinations?: any[];
+    Direction?: string;
+    DriverEmployeeId?: string;
+    DriverName?: string;
+    DriversLicenseNumber?: string;
+    EstimatedDepartureDateTime?: string;
+    FacilityLicenseNumber?: string;
+    FacilityName?: string;
+    Id?: number;
+    LastModified?: string;
+    Leg?: number;
+    Packages?: any[];
+    RecordedByUserName?: string;
+    RecordedDateTime?: string;
+    RestockDateTime?: string;
+    RetailerDeliveryNumber?: string;
+    RetailerDeliveryState?: string;
+    TotalPackages?: number;
+    TotalPrice?: number;
+    TotalPriceSold?: number;
+    VehicleInfo?: string;
+    VehicleLicensePlateNumber?: string;
+    VehicleMake?: string;
+    VehicleModel?: string;
+    VoidedDate?: string;
+}

package/dist/wrapper/src/models/ActiveDeliveriesRetailer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wrapper/src/models/ActiveDelivery.d.ts

@@ -0,0 +1,50 @@
+export interface ActiveDelivery {
+    AcceptedDateTime?: string;
+    ActualArrivalDateTime?: string;
+    ActualDepartureDateTime?: string;
+    ActualReturnArrivalDateTime?: string;
+    ActualReturnDepartureDateTime?: string;
+    CompletedDateTime?: string;
+    ConsumerId?: string;
+    DeliveryNumber?: string;
+    Direction?: string;
+    DriverEmployeeId?: string;
+    DriverName?: string;
+    DriversLicenseNumber?: string;
+    EstimatedArrivalDateTime?: string;
+    EstimatedDepartureDateTime?: string;
+    EstimatedReturnArrivalDateTime?: string;
+    EstimatedReturnDepartureDateTime?: string;
+    FacilityLicenseNumber?: string;
+    FacilityName?: string;
+    Id?: number;
+    LastModified?: string;
+    PatientLicenseNumber?: string;
+    PlannedRoute?: string;
+    RecipientAddressCity?: string;
+    RecipientAddressCounty?: string;
+    RecipientAddressPostalCode?: string;
+    RecipientAddressState?: string;
+    RecipientAddressStreet1?: string;
+    RecipientAddressStreet2?: string;
+    RecipientDeliveryZoneId?: number;
+    RecipientDeliveryZoneName?: string;
+    RecipientName?: string;
+    RecipientZoneId?: number;
+    RecordedByUserName?: string;
+    RecordedDateTime?: string;
+    SalesCustomerType?: string;
+    SalesDateTime?: string;
+    SalesDeliveryState?: string;
+    ShipperFacilityLicenseNumber?: string;
+    TotalPackages?: number;
+    TotalPrice?: number;
+    Transactions?: any[];
+    TransporterFacilityId?: number;
+    TransporterFacilityLicenseNumber?: string;
+    TransporterFacilityName?: string;
+    VehicleLicensePlateNumber?: string;
+    VehicleMake?: string;
+    VehicleModel?: string;
+    VoidedDate?: string;
+}

package/dist/wrapper/src/models/ActiveDelivery.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wrapper/src/models/ActiveJobType.d.ts

@@ -0,0 +1,12 @@
+import type { ProcessingJobActiveJobTypeAttributesItem } from './ProcessingJobActiveJobTypeAttributesItem';
+export interface ActiveJobType {
+    Attributes?: ProcessingJobActiveJobTypeAttributesItem[];
+    CategoryName?: string;
+    Description?: string;
+    ForItems?: boolean;
+    ForProcessingJobs?: boolean;
+    Id?: number;
+    Name?: string;
+    ProcessingSteps?: string;
+    RequiresProcessingJobAttributes?: boolean;
+}

package/dist/wrapper/src/models/ActiveJobType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wrapper/src/models/ActiveReceipt.d.ts

@@ -0,0 +1,19 @@
+export interface ActiveReceipt {
+    ArchivedDate?: string;
+    CaregiverLicenseNumber?: string;
+    ExternalReceiptNumber?: string;
+    Id?: number;
+    IdentificationMethod?: string;
+    IsFinal?: boolean;
+    LastModified?: string;
+    PatientLicenseNumber?: string;
+    PatientRegistrationLocationId?: number;
+    ReceiptNumber?: string;
+    RecordedByUserName?: string;
+    RecordedDateTime?: string;
+    SalesCustomerType?: string;
+    SalesDateTime?: string;
+    TotalPackages?: number;
+    TotalPrice?: number;
+    Transactions?: any[];
+}

package/dist/wrapper/src/models/ActiveReceipt.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wrapper/src/models/Additive.d.ts

@@ -0,0 +1,17 @@
+export interface Additive {
+    AdditiveTypeName?: string;
+    AmountUnitOfMeasure?: string;
+    ApplicationDevice?: string;
+    EpaRegistrationNumber?: string;
+    Note?: string;
+    PlantBatchId?: number;
+    PlantBatchName?: string;
+    PlantCount?: number;
+    ProductSupplier?: string;
+    ProductTradeName?: string;
+    Rate?: string;
+    RestrictiveEntryIntervalQuantityDescription?: string;
+    RestrictiveEntryIntervalTimeDescription?: string;
+    TotalAmountApplied?: number;
+    Volume?: number;
+}

package/dist/wrapper/src/models/Additive.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wrapper/src/models/AdditivesTemplate.d.ts

@@ -0,0 +1,18 @@
+import type { AdditivesTemplateActiveIngredientsItem } from './AdditivesTemplateActiveIngredientsItem';
+export interface AdditivesTemplate {
+    ActiveIngredients?: AdditivesTemplateActiveIngredientsItem[];
+    AdditiveType?: string;
+    AdditiveTypeName?: string;
+    ApplicationDevice?: string;
+    EpaRegistrationNumber?: string;
+    FacilityId?: number;
+    Id?: number;
+    IsActive?: boolean;
+    LastModified?: string;
+    Name?: string;
+    Note?: string;
+    ProductSupplier?: string;
+    ProductTradeName?: string;
+    RestrictiveEntryIntervalQuantityDescription?: string;
+    RestrictiveEntryIntervalTimeDescription?: string;
+}

package/dist/wrapper/src/models/AdditivesTemplate.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wrapper/src/models/AdditivesTemplateActiveIngredientsItem.d.ts

@@ -0,0 +1,4 @@
+export interface AdditivesTemplateActiveIngredientsItem {
+    Name?: string;
+    Percentage?: number;
+}

package/dist/wrapper/src/models/AdditivesTemplateActiveIngredientsItem.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wrapper/src/models/AdjustReason.d.ts

@@ -0,0 +1,7 @@
+export interface AdjustReason {
+    Name?: string;
+    RequiresImmatureWasteWeight?: boolean;
+    RequiresMatureWasteWeight?: boolean;
+    RequiresNote?: boolean;
+    RequiresWasteWeight?: boolean;
+}

package/dist/wrapper/src/models/AdjustReason.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wrapper/src/models/Adjustment.d.ts

@@ -0,0 +1,15 @@
+export interface Adjustment {
+    AdjustedByUserName?: string;
+    AdjustmentDate?: string;
+    AdjustmentNote?: string;
+    AdjustmentQuantity?: number;
+    AdjustmentReasonName?: string;
+    AdjustmentUnitOfMeasureAbbreviation?: string;
+    AdjustmentUnitOfMeasureName?: string;
+    ItemCategoryName?: string;
+    ItemName?: string;
+    PackageId?: number;
+    PackageLabTestResultExpirationDateTime?: string;
+    PackageLabel?: string;
+    PackagedDate?: string;
+}

package/dist/wrapper/src/models/Adjustment.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wrapper/src/models/Allotment.d.ts

@@ -0,0 +1,5 @@
+export interface Allotment {
+    Allotment?: number;
+    FacilityId?: number;
+    FacilityLicenseNumber?: string;
+}

package/dist/wrapper/src/models/Allotment.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wrapper/src/models/Batch.d.ts

@@ -0,0 +1,11 @@
+import type { LabTestsBatchItemCategoriesItem } from './LabTestsBatchItemCategoriesItem';
+import type { LabTestsBatchLabTestTypesItem } from './LabTestsBatchLabTestTypesItem';
+export interface Batch {
+    Id?: number;
+    ItemCategories?: LabTestsBatchItemCategoriesItem[];
+    ItemCategoryCount?: number;
+    LabTestTypeCount?: number;
+    LabTestTypes?: LabTestsBatchLabTestTypesItem[];
+    Name?: string;
+    RequiresAllFromLabTestBatch?: boolean;
+}

package/dist/wrapper/src/models/Batch.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wrapper/src/models/Brand.d.ts

@@ -0,0 +1,5 @@
+export interface Brand {
+    Id?: number;
+    Name?: string;
+    Status?: string;
+}

package/dist/wrapper/src/models/Brand.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wrapper/src/models/CaregiversStatus.d.ts

@@ -0,0 +1,5 @@
+export interface CaregiversStatus {
+    Active?: boolean;
+    CaregiverLicenseNumber?: string;
+    Patients?: string[];
+}

package/dist/wrapper/src/models/CaregiversStatus.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });