@lavalogic/scoria 0.0.1

package/dist/Types/Internal/AttributeOperation.d.ts

@@ -0,0 +1,30 @@
+export declare const enum AttributeOperation {
+    Preadvice = 0,
+    RequiredAtPreadvice = 0,//functionally identical
+    Order = 1,
+    RequiredAtOrder = 1,// functionally identical
+    Despatch = 2,
+    RequiredAtDespatch = 3,
+    ValidateAtDespatch = 4,
+    Kit = 5,
+    RequiredAtKit = 6,
+    ValidateAtKit = 7,
+    Pack = 8,
+    RequiredAtPack = 9,
+    ValidateAtPack = 10,
+    Pick = 11,
+    RequiredAtPick = 12,
+    ValidateAtPick = 13,
+    Receipt = 14,
+    RequiredAtReceipt = 15,
+    ValidateAtReceipt = 16,
+    ReceiptReturn = 17,
+    RequiredAtReceiptReturn = 18,
+    ValidateAtReceiptReturn = 19,
+    Sort = 20,
+    RequiredAtSort = 21,
+    ValidateAtSort = 22,
+    StockTake = 23,
+    RequiredAtStockTake = 24,
+    ValidateAtStockTake = 25
+}

package/dist/Types/Internal/AttributeOperation.js

@@ -0,0 +1,33 @@
+export var AttributeOperation;
+(function (AttributeOperation) {
+    AttributeOperation[AttributeOperation["Preadvice"] = 0] = "Preadvice";
+    // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values
+    AttributeOperation[AttributeOperation["RequiredAtPreadvice"] = 0] = "RequiredAtPreadvice";
+    AttributeOperation[AttributeOperation["Order"] = 1] = "Order";
+    // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values
+    AttributeOperation[AttributeOperation["RequiredAtOrder"] = 1] = "RequiredAtOrder";
+    AttributeOperation[AttributeOperation["Despatch"] = 2] = "Despatch";
+    AttributeOperation[AttributeOperation["RequiredAtDespatch"] = 3] = "RequiredAtDespatch";
+    AttributeOperation[AttributeOperation["ValidateAtDespatch"] = 4] = "ValidateAtDespatch";
+    AttributeOperation[AttributeOperation["Kit"] = 5] = "Kit";
+    AttributeOperation[AttributeOperation["RequiredAtKit"] = 6] = "RequiredAtKit";
+    AttributeOperation[AttributeOperation["ValidateAtKit"] = 7] = "ValidateAtKit";
+    AttributeOperation[AttributeOperation["Pack"] = 8] = "Pack";
+    AttributeOperation[AttributeOperation["RequiredAtPack"] = 9] = "RequiredAtPack";
+    AttributeOperation[AttributeOperation["ValidateAtPack"] = 10] = "ValidateAtPack";
+    AttributeOperation[AttributeOperation["Pick"] = 11] = "Pick";
+    AttributeOperation[AttributeOperation["RequiredAtPick"] = 12] = "RequiredAtPick";
+    AttributeOperation[AttributeOperation["ValidateAtPick"] = 13] = "ValidateAtPick";
+    AttributeOperation[AttributeOperation["Receipt"] = 14] = "Receipt";
+    AttributeOperation[AttributeOperation["RequiredAtReceipt"] = 15] = "RequiredAtReceipt";
+    AttributeOperation[AttributeOperation["ValidateAtReceipt"] = 16] = "ValidateAtReceipt";
+    AttributeOperation[AttributeOperation["ReceiptReturn"] = 17] = "ReceiptReturn";
+    AttributeOperation[AttributeOperation["RequiredAtReceiptReturn"] = 18] = "RequiredAtReceiptReturn";
+    AttributeOperation[AttributeOperation["ValidateAtReceiptReturn"] = 19] = "ValidateAtReceiptReturn";
+    AttributeOperation[AttributeOperation["Sort"] = 20] = "Sort";
+    AttributeOperation[AttributeOperation["RequiredAtSort"] = 21] = "RequiredAtSort";
+    AttributeOperation[AttributeOperation["ValidateAtSort"] = 22] = "ValidateAtSort";
+    AttributeOperation[AttributeOperation["StockTake"] = 23] = "StockTake";
+    AttributeOperation[AttributeOperation["RequiredAtStockTake"] = 24] = "RequiredAtStockTake";
+    AttributeOperation[AttributeOperation["ValidateAtStockTake"] = 25] = "ValidateAtStockTake";
+})(AttributeOperation || (AttributeOperation = {}));

package/dist/Types/Internal/BigRadioOption.d.ts

@@ -0,0 +1,5 @@
+export interface BigRadioOption<T> {
+    label: string;
+    value: T;
+    info?: string;
+}

package/dist/Types/Internal/BigRadioOption.js

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

package/dist/Types/Internal/ButtonProp.d.ts

@@ -0,0 +1,11 @@
+import type { ColourSet } from '../../scss/colours.js';
+import type { HTMLButtonAttributes } from 'svelte/elements';
+export interface ButtonProp {
+    label: string;
+    colourSet?: ColourSet;
+    callback?: () => void;
+    type?: HTMLButtonAttributes['type'];
+    margin?: 'left' | 'right';
+    barcodeValue?: string;
+    isValid?: boolean | Promise<boolean>;
+}

package/dist/Types/Internal/ButtonProp.js

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

package/dist/Types/Internal/CallbackButton.d.ts

@@ -0,0 +1,10 @@
+import type { ButtonProps } from '../../Components/Button.svelte';
+import type { ColourSet } from '../../scss/colours.js';
+export interface CallbackButton {
+    label: string;
+    callback?: () => void | Promise<void>;
+    type?: ButtonProps['type'];
+    colourSet?: ColourSet;
+    disabled?: boolean;
+    left?: boolean;
+}

package/dist/Types/Internal/CallbackButton.js

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

package/dist/Types/Internal/DateChange.d.ts

@@ -0,0 +1,5 @@
+import type { DatePickerType } from './DatePickerType.js';
+export interface DateChange<T> {
+    type: DatePickerType;
+    changedData: T;
+}

package/dist/Types/Internal/DateChange.js

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

package/dist/Types/Internal/DatePickerType.d.ts

@@ -0,0 +1,8 @@
+export declare const enum DatePickerType {
+    Year = "year",
+    Month = "month",
+    Day = "day",
+    Hours = "hours",
+    Minutes = "minutes",
+    Seconds = "seconds"
+}

package/dist/Types/Internal/DatePickerType.js

@@ -0,0 +1,9 @@
+export var DatePickerType;
+(function (DatePickerType) {
+    DatePickerType["Year"] = "year";
+    DatePickerType["Month"] = "month";
+    DatePickerType["Day"] = "day";
+    DatePickerType["Hours"] = "hours";
+    DatePickerType["Minutes"] = "minutes";
+    DatePickerType["Seconds"] = "seconds";
+})(DatePickerType || (DatePickerType = {}));

package/dist/Types/Internal/FloService.d.ts

@@ -0,0 +1,7 @@
+export declare const FloService: Record<FloServiceName, FloService>;
+type FloServiceName = 'Accounts' | 'Adjustments' | 'Allocations' | 'Auths' | 'Buckets' | 'Couriers' | 'Despatch' | 'Floats' | 'Jobs' | 'Kits' | 'Locations' | 'Movements' | 'Orders' | 'Packs' | 'Picks' | 'Pods' | 'Pools' | 'Preadvices' | 'Prints' | 'Products' | 'Putaway' | 'Receipt' | 'Registry' | 'Reports' | 'Sortations' | 'StockTake' | 'System' | 'Transactions';
+export interface FloService {
+    readonly uri: string;
+    readonly version: number;
+}
+export {};

package/dist/Types/Internal/FloService.js

@@ -0,0 +1,30 @@
+export const FloService = {
+    Accounts: { uri: 'accounts', version: 0 },
+    Adjustments: { uri: 'adjustments', version: 0 },
+    Allocations: { uri: 'allocations', version: 0 },
+    Auths: { uri: 'auths', version: 0 },
+    Buckets: { uri: 'buckets', version: 0 },
+    Couriers: { uri: 'couriers', version: 0 },
+    Despatch: { uri: 'despatch', version: 0 },
+    Floats: { uri: 'floats', version: 0 },
+    Jobs: { uri: 'jobs', version: 0 },
+    Kits: { uri: 'kits', version: 0 },
+    Locations: { uri: 'locations', version: 0 },
+    Movements: { uri: 'movements', version: 0 },
+    Orders: { uri: 'orders', version: 0 },
+    Packs: { uri: 'packs', version: 0 },
+    Picks: { uri: 'picks', version: 0 },
+    Pods: { uri: 'pods', version: 0 },
+    Pools: { uri: 'pools', version: 0 },
+    Preadvices: { uri: 'preadvices', version: 0 },
+    Prints: { uri: 'prints', version: 0 },
+    Products: { uri: 'products', version: 0 },
+    Putaway: { uri: 'putaway', version: 0 },
+    Receipt: { uri: 'receipt', version: 0 },
+    Registry: { uri: 'registry', version: 0 },
+    Reports: { uri: 'reports', version: 0 },
+    Sortations: { uri: 'sortations', version: 0 },
+    StockTake: { uri: 'stocktake', version: 0 },
+    System: { uri: 'system', version: 0 },
+    Transactions: { uri: 'transactions', version: 0 }
+};

package/dist/Types/Internal/GridItem.d.ts

@@ -0,0 +1,4 @@
+import type { GridNumberItem } from './GridNumberItem.js';
+import type { GridSelectItem } from './GridSelectItem.js';
+import type { GridTextItem } from './GridTextItem.js';
+export type GridItem<V, VP> = GridTextItem | GridNumberItem | (V extends object ? (VP extends string & keyof V ? GridSelectItem<V, VP> : never) : never);

package/dist/Types/Internal/GridItem.js

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

package/dist/Types/Internal/GridMultiSelectItem.d.ts

@@ -0,0 +1,4 @@
+import type { GridSelectItem } from './GridSelectItem.js';
+export interface GridMultiSelectItem<V extends object, VP extends string & keyof V> extends GridSelectItem<V, VP> {
+    multi: true;
+}

package/dist/Types/Internal/GridMultiSelectItem.js

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

package/dist/Types/Internal/GridMultiSelectItemAsObject.d.ts

@@ -0,0 +1,5 @@
+import type { GridMultiSelectItem } from './GridMultiSelectItem.js';
+export interface GridMultiSelectItemAsObject<V extends object, VP extends string & keyof V> extends GridMultiSelectItem<V, VP> {
+    valueAsObject: true;
+    value: V[];
+}

package/dist/Types/Internal/GridMultiSelectItemAsObject.js

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

package/dist/Types/Internal/GridMultiSelectItemAsPrimitive.d.ts

@@ -0,0 +1,5 @@
+import type { GridMultiSelectItem } from './GridMultiSelectItem.js';
+export interface GridMultiSelectItemAsPrimitive<V extends object, VP extends string & keyof V> extends GridMultiSelectItem<V, VP> {
+    valueAsObject: false;
+    value: Array<V[VP]>;
+}

package/dist/Types/Internal/GridMultiSelectItemAsPrimitive.js

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

package/dist/Types/Internal/GridNumberItem.d.ts

@@ -0,0 +1,4 @@
+import type { GridStringItem } from './GridStringItem.js';
+export interface GridNumberItem extends GridStringItem {
+    type: 'number';
+}

package/dist/Types/Internal/GridNumberItem.js

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

package/dist/Types/Internal/GridSelectItem.d.ts

@@ -0,0 +1,12 @@
+import type { NonNullableKey } from './Misc.js';
+export interface GridSelectItem<V extends object, VP extends keyof V> {
+    name: string;
+    label: string;
+    options: V[] | Promise<V[]>;
+    type: 'select';
+    labelProp: NonNullableKey<V>;
+    valueProp: VP;
+    info: string;
+    disabled: boolean;
+    invalid?: boolean;
+}

package/dist/Types/Internal/GridSelectItem.js

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

package/dist/Types/Internal/GridSingleSelectItem.d.ts

@@ -0,0 +1,5 @@
+import type { GridSelectItem } from './GridSelectItem.js';
+export interface GridSingleSelectItem<V extends object, VP extends keyof V> extends GridSelectItem<V, VP> {
+    multi?: false;
+    required?: boolean;
+}

package/dist/Types/Internal/GridSingleSelectItem.js

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

package/dist/Types/Internal/GridSingleSelectItemAsObject.d.ts

@@ -0,0 +1,5 @@
+import type { GridSingleSelectItem } from './GridSingleSelectItem.js';
+export interface GridSingleSelectItemAsObject<V extends object, VP extends keyof V> extends GridSingleSelectItem<V, VP> {
+    valueAsObject: true;
+    value: V | null;
+}

package/dist/Types/Internal/GridSingleSelectItemAsObject.js

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

package/dist/Types/Internal/GridSingleSelectItemAsPrimitive.d.ts

@@ -0,0 +1,5 @@
+import type { GridSingleSelectItem } from './GridSingleSelectItem.js';
+export interface GridSingleSelectItemAsPrimitive<V extends object, VP extends keyof V> extends GridSingleSelectItem<V, VP> {
+    valueAsObject: false;
+    value: V[VP] | null;
+}

package/dist/Types/Internal/GridSingleSelectItemAsPrimitive.js

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

package/dist/Types/Internal/GridStringItem.d.ts

@@ -0,0 +1,9 @@
+export interface GridStringItem {
+    label: string;
+    info: string;
+    value: string | null;
+    disabled: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    type?: 'text' | 'email' | 'tel' | 'number';
+}

package/dist/Types/Internal/GridStringItem.js

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

package/dist/Types/Internal/GridTextItem.d.ts

@@ -0,0 +1,4 @@
+import type { GridStringItem } from './GridStringItem.js';
+export interface GridTextItem extends GridStringItem {
+    type?: 'text' | 'email' | 'tel';
+}

package/dist/Types/Internal/GridTextItem.js

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

package/dist/Types/Internal/IdentifiableToastMessage.d.ts

@@ -0,0 +1,5 @@
+import type { ToastMessage } from './ToastMessage.js';
+export interface IdentifiableToastMessage extends ToastMessage {
+    readonly id: number;
+    readonly close?: () => void;
+}

package/dist/Types/Internal/IdentifiableToastMessage.js

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

package/dist/Types/Internal/InputVariant.d.ts

@@ -0,0 +1,6 @@
+export declare const enum InputVariant {
+    Default = 0,
+    Modal = 1,
+    ModalThin = 2,
+    Table = 3
+}

package/dist/Types/Internal/InputVariant.js

@@ -0,0 +1,7 @@
+export var InputVariant;
+(function (InputVariant) {
+    InputVariant[InputVariant["Default"] = 0] = "Default";
+    InputVariant[InputVariant["Modal"] = 1] = "Modal";
+    InputVariant[InputVariant["ModalThin"] = 2] = "ModalThin";
+    InputVariant[InputVariant["Table"] = 3] = "Table";
+})(InputVariant || (InputVariant = {}));

package/dist/Types/Internal/Misc.d.ts

@@ -0,0 +1,271 @@
+import type { IApplicationIdentifier } from './ApplicationIdentifier.js';
+import { type Static, type TSchema } from '@sinclair/typebox';
+export declare const nullable: <T extends TSchema>(type: T) => import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnion<[import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TNull, T]>;
+export type ParsedBarcode = Map<IApplicationIdentifier, string>;
+export declare const TypedString: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TString;
+export type TypedString = Static<typeof TypedString>;
+export declare const NullableString: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnion<[import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TNull, import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TString]>;
+export type NullableString = Static<typeof NullableString>;
+export declare const TypedBoolean: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TBoolean;
+export type TypedBoolean = Static<typeof TypedBoolean>;
+export declare const NullableBoolean: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnion<[import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TNull, import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TBoolean]>;
+export type NullableBoolean = Static<typeof NullableBoolean>;
+export declare const TypedNumber: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TNumber;
+export type TypedNumber = Static<typeof TypedNumber>;
+export declare const NullableNumber: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnion<[import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TNull, import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TNumber]>;
+export type NullableNumber = Static<typeof NullableNumber>;
+export declare const NaturalNumber: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TInteger;
+export type NaturalNumber = Static<typeof NaturalNumber>;
+export declare const NullableNaturalNumber: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnion<[import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TNull, import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TInteger]>;
+export type NullableNaturalNumber = Static<typeof NullableNaturalNumber>;
+export declare const PositiveDecimal: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TNumber;
+export type PositiveDecimal = Static<typeof PositiveDecimal>;
+export declare const PositiveInteger: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TInteger;
+export type PositiveInteger = Static<typeof PositiveInteger>;
+export declare const NullablePositiveInteger: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnion<[import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TNull, import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TInteger]>;
+export type NullablePositiveInteger = Static<typeof NullablePositiveInteger>;
+export type AccountID = number & {
+    __brand: 'AccountID';
+};
+export declare const AccountID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<AccountID>;
+export type BrandedString<T> = string & {
+    __brand: T;
+};
+export type BrandedNumber<T> = number & {
+    __brand: T;
+};
+export type BrandedInteger<T> = number & {
+    __brand: T;
+};
+export type AccountCourierCodeMatrixID = BrandedNumber<'AccountCourierCodeMatrixID'>;
+export declare const AccountCourierCodeMatrixID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<AccountCourierCodeMatrixID>;
+export type AccountCourierServiceCode = BrandedString<'AccountCourierServiceCode'>;
+export declare const AccountCourierServiceCode: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<AccountCourierServiceCode>;
+export type AICode = BrandedString<'AICode'>;
+export declare const AICode: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<AICode>;
+export type RawBarcode = BrandedString<'RawBarcode'>;
+export declare const RawBarcode: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<RawBarcode>;
+export type AddressID = BrandedInteger<'AddressID'>;
+export declare const AddressID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<AddressID>;
+export type AdjustmentTypeID = BrandedInteger<'AdjustmentTypeID'>;
+export declare const AdjustmentTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<AdjustmentTypeID>;
+export type BatchTypeAccountMatrixID = BrandedInteger<'BatchTypeAccountMatrixID'>;
+export declare const BatchTypeAccountMatrixID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<BatchTypeAccountMatrixID>;
+export type PodLineBatchTypeID = BrandedInteger<'PodLineBatchTypeID'>;
+export declare const PodLineBatchTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PodLineBatchTypeID>;
+export type BucketUUID = BrandedString<'BucketUUID'>;
+export declare const BucketUUID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<BucketUUID>;
+export type CountryID = BrandedInteger<'CountryID'>;
+export declare const CountryID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<CountryID>;
+export type CourierAccountID = BrandedInteger<'CourierAccountID'>;
+export declare const CourierAccountID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<CourierAccountID>;
+export type SystemCourierCode = BrandedString<'SystemCourierCode'>;
+export declare const SystemCourierCode: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<SystemCourierCode>;
+export type AccountCourierCode = BrandedString<'AccountCourierCode'>;
+export declare const AccountCourierCode: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<AccountCourierCode>;
+export type CourierConsignmentID = BrandedInteger<'CourierConsignmentID'>;
+export declare const CourierConsignmentID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<CourierConsignmentID>;
+export type CourierID = BrandedInteger<'CourierID'>;
+export declare const CourierID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<CourierID>;
+export type CollectionPostcode = BrandedString<'CollectionPostcode'>;
+export declare const CollectionPostcode: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<CollectionPostcode>;
+export type PackReferenceID = BrandedInteger<'PackReferenceID'>;
+export declare const PackReferenceID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PackReferenceID>;
+export type CourierServiceCode = BrandedString<'CourierServiceCode'>;
+export declare const CourierServiceCode: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<CourierServiceCode>;
+export type CustomerID = BrandedInteger<'CustomerID'>;
+export declare const CustomerID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<CustomerID>;
+export type CustomerTypeID = BrandedInteger<'CustomerTypeID'>;
+export declare const CustomerTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<CustomerTypeID>;
+export type DateTypeAccountMatrixID = BrandedInteger<'DateTypeAccountMatrixID'>;
+export declare const DateTypeAccountMatrixID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<DateTypeAccountMatrixID>;
+export type PodLineDateTypeID = BrandedInteger<'PodLineDateTypeID'>;
+export declare const PodLineDateTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PodLineDateTypeID>;
+export type DefinitionSegmentTypeID = BrandedInteger<'DefinitionSegmentTypeID'>;
+export declare const DefinitionSegmentTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<DefinitionSegmentTypeID>;
+export type DeliveryPostcode = BrandedString<'DeliveryPostcode'>;
+export declare const DeliveryPostcode: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<DeliveryPostcode>;
+export type DocumentMatrixID = BrandedInteger<'DocumentMatrixID'>;
+export declare const DocumentMatrixID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<DocumentMatrixID>;
+export type DocumentTypeID = BrandedInteger<'DocumentTypeID'>;
+export declare const DocumentTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<DocumentTypeID>;
+export type DocumentFormat = BrandedString<'DocumentFormat'>;
+export declare const DocumentFormat: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<DocumentFormat>;
+export type InputDate = BrandedString<'InputDate'>;
+export declare const InputDate: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<InputDate>;
+export type InputDateWithTime = BrandedString<'InputDateWithTime'>;
+export declare const InputDateWithTime: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<InputDateWithTime>;
+export type FloDate = BrandedString<'FloDate'>;
+export declare const FloDate: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<FloDate>;
+export type HoldTypeID = BrandedInteger<'HoldTypeID'>;
+export declare const HoldTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<HoldTypeID>;
+export type HoldTypeAccountMatrixID = BrandedInteger<'HoldTypeAccountMatrixID'>;
+export declare const HoldTypeAccountMatrixID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<HoldTypeAccountMatrixID>;
+export type JobID = BrandedInteger<'JobID'>;
+export declare const JobID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<JobID>;
+export type JobStatusID = BrandedInteger<'JobStatusID'>;
+export declare const JobStatusID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<JobStatusID>;
+export type JobTypeID = BrandedInteger<'JobTypeID'>;
+export declare const JobTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<JobTypeID>;
+export type KitUUID = BrandedString<'KitUUID'>;
+export declare const KitUUID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<KitUUID>;
+export type MovementID = BrandedInteger<'MovementID'>;
+export declare const MovementID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<MovementID>;
+export type MovementLineID = BrandedInteger<'MovementLineID'>;
+export declare const MovementLineID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<MovementLineID>;
+export type OrderID = BrandedInteger<'OrderID'>;
+export declare const OrderID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<OrderID>;
+export type OrderLineID = BrandedInteger<'OrderLineID'>;
+export declare const OrderLineID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<OrderLineID>;
+export type OrderLineMethodID = BrandedInteger<'OrderLineMethodID'>;
+export declare const OrderLineMethodID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<OrderLineMethodID>;
+export type OrderLineShortageReasonID = BrandedInteger<'OrderLineShortageReasonID'>;
+export declare const OrderLineShortageReasonID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<OrderLineShortageReasonID>;
+export type OrderLineReasonTypeID = BrandedInteger<'OrderLineReasonTypeID'>;
+export declare const OrderLineReasonTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<OrderLineReasonTypeID>;
+export type OrderTagTypeID = BrandedInteger<'OrderTagTypeID'>;
+export declare const OrderTagTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<OrderTagTypeID>;
+export type OutboundTypeID = BrandedInteger<'OutboundTypeID'>;
+export declare const OutboundTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<OutboundTypeID>;
+export type OutboundTypeAccountMatrixID = BrandedInteger<'OutboundTypeAccountMatrixID'>;
+export declare const OutboundTypeAccountMatrixID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<OutboundTypeAccountMatrixID>;
+export type OutboundStatusID = BrandedInteger<'OutboundStatusID'>;
+export declare const OutboundStatusID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<OutboundStatusID>;
+export type OutboundStatusName = BrandedString<'OutboundStatusName'>;
+export declare const OutboundStatusName: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<OutboundStatusName>;
+export type PickJobID = BrandedInteger<'PickJobID'>;
+export declare const PickJobID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PickJobID>;
+export type PickWaveID = BrandedInteger<'PickWaveID'>;
+export declare const PickWaveID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PickWaveID>;
+export type PickUUID = BrandedString<'PickUUID'>;
+export declare const PickUUID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PickUUID>;
+export type PodTypeID = BrandedInteger<'PodTypeID'>;
+export declare const PodTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PodTypeID>;
+export type PodAliasID = BrandedInteger<'PodAliasID'>;
+export declare const PodAliasID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PodAliasID>;
+export type PodAliasTypeID = BrandedInteger<'PodAliasTypeID'>;
+export declare const PodAliasTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PodAliasTypeID>;
+export type PodAlias = BrandedString<'PodAlias'>;
+export declare const PodAlias: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PodAlias>;
+export type PodUUID = BrandedString<'PodUUID'>;
+export declare const PodUUID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PodUUID>;
+export type PodLineQuantityID = BrandedInteger<'PodLineQuantityID'>;
+export declare const PodLineQuantityID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PodLineQuantityID>;
+export type PodLineUUID = BrandedString<'PodLineUUID'>;
+export declare const PodLineUUID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PodLineUUID>;
+export type PoolAlias = BrandedString<'PoolAlias'>;
+export declare const PoolAlias: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PoolAlias>;
+export type PoolID = BrandedInteger<'PoolID'>;
+export declare const PoolID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PoolID>;
+export type PoolTypeID = BrandedInteger<'PoolTypeID'>;
+export declare const PoolTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PoolTypeID>;
+export type Postcode = BrandedString<'Postcode'>;
+export declare const Postcode: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<Postcode>;
+export type PreadviceID = BrandedInteger<'PreadviceID'>;
+export declare const PreadviceID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PreadviceID>;
+export type PreadviceLineID = BrandedInteger<'PreadviceLineID'>;
+export declare const PreadviceLineID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PreadviceLineID>;
+export type PreadviceStatusID = BrandedInteger<'PreadviceStatusID'>;
+export declare const PreadviceStatusID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PreadviceStatusID>;
+export type PreadviceTypeID = BrandedInteger<'PreadviceTypeID'>;
+export declare const PreadviceTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PreadviceTypeID>;
+export type PreadviceTagTypeID = BrandedInteger<'PreadviceTagTypeID'>;
+export declare const PreadviceTagTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PreadviceTagTypeID>;
+export type PreadviceTypeAccountMatrixID = BrandedInteger<'PreadviceTypeAccountMatrixID'>;
+export declare const PreadviceTypeAccountMatrixID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PreadviceTypeAccountMatrixID>;
+export type PrinterID = BrandedInteger<'PrinterID'>;
+export declare const PrinterID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PrinterID>;
+export type ProductID = BrandedInteger<'ProductID'>;
+export declare const ProductID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<ProductID>;
+export type ProductKitMatrixID = BrandedInteger<'ProductKitMatrixID'>;
+export declare const ProductKitMatrixID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<ProductKitMatrixID>;
+export type ProductTagTypeID = BrandedInteger<'ProductTagTypeID'>;
+export declare const ProductTagTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<ProductTagTypeID>;
+export type PurchaseOrderTypeAccountMatrixID = BrandedInteger<'PurchaseOrderTypeAccountMatrixID'>;
+export declare const PurchaseOrderTypeAccountMatrixID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PurchaseOrderTypeAccountMatrixID>;
+export type PodLinePurchaseOrderTypeID = BrandedInteger<'PodLinePurchaseOrderTypeID'>;
+export declare const PodLinePurchaseOrderTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PodLinePurchaseOrderTypeID>;
+export type ReplenJobID = BrandedInteger<'ReplenJobID'>;
+export declare const ReplenJobID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<ReplenJobID>;
+export type QuantityTypeID = BrandedInteger<'QuantityTypeID'>;
+export declare const QuantityTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<QuantityTypeID>;
+export type ReasonForExportID = BrandedInteger<'ReasonForExportID'>;
+export declare const ReasonForExportID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<ReasonForExportID>;
+export type SegmentFullName = BrandedString<'SegmentFullName'>;
+export declare const SegmentFullName: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<SegmentFullName>;
+export type SegmentID = BrandedInteger<'SegmentID'>;
+export declare const SegmentID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<SegmentID>;
+export type SegmentStatusID = BrandedInteger<'SegmentStatusID'>;
+export declare const SegmentStatusID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<SegmentStatusID>;
+export type SegmentProcessID = BrandedInteger<'SegmentProcessID'>;
+export declare const SegmentProcessID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<SegmentProcessID>;
+export type PickDeviceUUID = BrandedString<'PickDeviceUUID'>;
+export declare const PickDeviceUUID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PickDeviceUUID>;
+export type PickGroupID = BrandedInteger<'PickGroupID'>;
+export declare const PickGroupID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PickGroupID>;
+export type PodLineSerialTypeID = BrandedInteger<'PodLineSerialTypeID'>;
+export declare const PodLineSerialTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PodLineSerialTypeID>;
+export type PackReference = BrandedString<'PackReference'>;
+export declare const PackReference: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PackReference>;
+export type ShipmentID = BrandedInteger<'ShipmentID'>;
+export declare const ShipmentID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<ShipmentID>;
+export type ShipmentSetID = BrandedInteger<'ShipmentSetID'>;
+export declare const ShipmentSetID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<ShipmentSetID>;
+export type ShipmentSetLineID = BrandedInteger<'ShipmentSetLineID'>;
+export declare const ShipmentSetLineID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<ShipmentSetLineID>;
+export type ShipmentSetTypeID = BrandedInteger<'ShipmentSetTypeID'>;
+export declare const ShipmentSetTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<ShipmentSetTypeID>;
+export type SKU = BrandedString<'SKU'>;
+export declare const SKU: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<SKU>;
+export type SnapshotPickableUUID = BrandedString<'SnapshotPickableUUID'>;
+export declare const SnapshotPickableUUID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<SnapshotPickableUUID>;
+export type SnapshotPackableUUID = BrandedString<'SnapshotPackableUUID'>;
+export declare const SnapshotPackableUUID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<SnapshotPackableUUID>;
+export type SnapshotKittableUUID = BrandedString<'SnapshotKittableUUID'>;
+export declare const SnapshotKittableUUID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<SnapshotKittableUUID>;
+export type SupplierID = BrandedInteger<'SupplierID'>;
+export declare const SupplierID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<SupplierID>;
+export type TagTypeAccountMatrixID = BrandedInteger<'TagTypeAccountMatrixID'>;
+export declare const TagTypeAccountMatrixID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<TagTypeAccountMatrixID>;
+export type PodLineTagTypeID = BrandedInteger<'PodLineTagTypeID'>;
+export declare const PodLineTagTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<PodLineTagTypeID>;
+export type TemplateID = BrandedInteger<'TemplateID'>;
+export declare const TemplateID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<TemplateID>;
+export type TemplateTypeID = BrandedInteger<'TemplateTypeID'>;
+export declare const TemplateTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<TemplateTypeID>;
+export type TransactionID = BrandedInteger<'TransactionID'>;
+export declare const TransactionID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<TransactionID>;
+export type JournalID = BrandedInteger<'JournalID'>;
+export declare const JournalID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<JournalID>;
+export type OperationTypeID = BrandedInteger<'OperationTypeID'>;
+export declare const OperationTypeID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<OperationTypeID>;
+export type UserID = BrandedInteger<'UserID'>;
+export declare const UserID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<UserID>;
+export type UOMID = BrandedInteger<'UOMID'>;
+export declare const UOMID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<UOMID>;
+export type WarehouseID = BrandedInteger<'WarehouseID'>;
+export declare const WarehouseID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<WarehouseID>;
+export type MiscID = BrandedInteger<'MiscID'>;
+export declare const MiscID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<MiscID>;
+export type ZoneID = BrandedInteger<'ZoneID'>;
+export declare const ZoneID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<ZoneID>;
+export type WeightUnitOfMeasureID = BrandedInteger<'WeightUnitOfMeasureID'>;
+export declare const WeightUnitOfMeasureID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<WeightUnitOfMeasureID>;
+export type DimensionUnitOfMeasureID = BrandedInteger<'DimensionUnitOfMeasureID'>;
+export declare const DimensionUnitOfMeasureID: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<DimensionUnitOfMeasureID>;
+export type Grams = BrandedInteger<'Grams'>;
+export declare const Grams: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<Grams>;
+export type Kilograms = BrandedNumber<'Kilograms'>;
+export declare const Kilograms: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<Kilograms>;
+export type Millimetres = BrandedNumber<'Millimetres'>;
+export declare const Millimetres: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<Millimetres>;
+export type Centimetres = BrandedNumber<'Centimetres'>;
+export declare const Centimetres: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnsafe<Centimetres>;
+export interface ValueWrapper<T = string> {
+    value: T;
+}
+export type NonNullableKey<T> = T extends null ? never : string & keyof T;
+export type ValueProp<V> = keyof V & string;
+export type StringCallback = (value: RawBarcode) => boolean | void | Promise<boolean | void>;
+export type Unsubscriber = () => void;
+export type Pixels = number;