@endevops/peppol-schema 0.0.1

package/dist/invoice-response-codes/invoice-response-codes-order.js

@@ -0,0 +1,31 @@
+//#region src/invoice-response-codes/invoice-response-codes-order.ts
+const invoiceResponseCodesOrder = {
+	AB: [
+		"IP",
+		"UQ",
+		"AP",
+		"CA",
+		"PD",
+		"RE"
+	],
+	AP: ["PD"],
+	CA: ["PD"],
+	IP: [
+		"UQ",
+		"CA",
+		"AP",
+		"PD",
+		"RE"
+	],
+	PD: [],
+	RE: [],
+	UQ: [
+		"CA",
+		"AP",
+		"RE"
+	]
+};
+//#endregion
+export { invoiceResponseCodesOrder };
+
+//# sourceMappingURL=invoice-response-codes-order.js.map

package/dist/invoice-response-codes/invoice-response-codes-order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoice-response-codes-order.js","names":[],"sources":["../../src/invoice-response-codes/invoice-response-codes-order.ts"],"sourcesContent":["import type { invoiceStatusCodesKeys } from '#/values/invoice-status-codes.generated';\n\ntype StatusCode = (typeof invoiceStatusCodesKeys)[number];\n\nexport const invoiceResponseCodesOrder: Record<StatusCode, Array<StatusCode>> = {\n  AB: ['IP', 'UQ', 'AP', 'CA', 'PD', 'RE'],\n  AP: ['PD'],\n  CA: ['PD'],\n  IP: ['UQ', 'CA', 'AP', 'PD', 'RE'],\n  PD: [],\n  RE: [],\n  UQ: ['CA', 'AP', 'RE'],\n};\n"],"mappings":";AAIA,MAAa,4BAAmE;CAC9E,IAAI;EAAC;EAAM;EAAM;EAAM;EAAM;EAAM;CAAI;CACvC,IAAI,CAAC,IAAI;CACT,IAAI,CAAC,IAAI;CACT,IAAI;EAAC;EAAM;EAAM;EAAM;EAAM;CAAI;CACjC,IAAI,CAAC;CACL,IAAI,CAAC;CACL,IAAI;EAAC;EAAM;EAAM;CAAI;AACvB"}

package/dist/node_modules/.pnpm/ts-extras@1.3.0/node_modules/ts-extras/distribution/object-entries.js

@@ -0,0 +1,26 @@
+//#region node_modules/.pnpm/ts-extras@1.3.0/node_modules/ts-extras/distribution/object-entries.js
+/**
+A strongly-typed version of `Object.entries()`.
+
+This is useful since `Object.entries()` always returns an array of `Array<[string, T]>`. This function returns a strongly-typed array of the entries of the given object.
+
+- [TypeScript issues about this](https://github.com/microsoft/TypeScript/pull/12253)
+
+@example
+```
+import {objectEntries} from 'ts-extras';
+
+const stronglyTypedEntries = objectEntries({a: 1, b: 2, c: 3});
+//=> Array<['a' | 'b' | 'c', number]>
+
+const untypedEntries = Object.entries({a: 1, b: 2, c: 3});
+//=> Array<[string, number]>
+```
+
+@category Improved builtin
+*/
+const objectEntries = Object.entries;
+//#endregion
+export { objectEntries };
+
+//# sourceMappingURL=object-entries.js.map

package/dist/node_modules/.pnpm/ts-extras@1.3.0/node_modules/ts-extras/distribution/object-entries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-entries.js","names":[],"sources":["../../../../../../../node_modules/.pnpm/ts-extras@1.3.0/node_modules/ts-extras/distribution/object-entries.js"],"sourcesContent":["/**\nA strongly-typed version of `Object.entries()`.\n\nThis is useful since `Object.entries()` always returns an array of `Array<[string, T]>`. This function returns a strongly-typed array of the entries of the given object.\n\n- [TypeScript issues about this](https://github.com/microsoft/TypeScript/pull/12253)\n\n@example\n```\nimport {objectEntries} from 'ts-extras';\n\nconst stronglyTypedEntries = objectEntries({a: 1, b: 2, c: 3});\n//=> Array<['a' | 'b' | 'c', number]>\n\nconst untypedEntries = Object.entries({a: 1, b: 2, c: 3});\n//=> Array<[string, number]>\n```\n\n@category Improved builtin\n*/\n// eslint-disable-next-line @typescript-eslint/no-restricted-types -- We intentionally use `object` to accept interfaces.\n// Intentionally unsafe cast to provide strongly-typed Object.entries().\nexport const objectEntries = Object.entries;\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,gBAAgB,OAAO"}

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/all-union-fields.d.ts

@@ -0,0 +1,83 @@
+import { KeysOfUnion } from "./keys-of-union.js";
+import { UnknownArray } from "./unknown-array.js";
+import { NonRecursiveType } from "./internal/type.js";
+import { Simplify } from "./simplify.js";
+import { ReadonlyKeysOfUnion, ValueOfUnion } from "./internal/object.js";
+import { SharedUnionFields } from "./shared-union-fields.js";
+//#region node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/all-union-fields.d.ts
+/**
+Create a type with all fields from a union of object types.
+
+Use-cases:
+- You want a safe object type where each key exists in the union object.
+
+@example
+```
+import type {AllUnionFields} from 'type-fest';
+
+type Cat = {
+	name: string;
+	type: 'cat';
+	catType: string;
+};
+
+type Dog = {
+	name: string;
+	type: 'dog';
+	dogType: string;
+};
+
+function displayPetInfo(petInfo: Cat | Dog) {
+	// typeof petInfo =>
+	// {
+	// 	name: string;
+	// 	type: 'cat';
+	// 	catType: string;
+	// } | {
+	// 	name: string;
+	// 	type: 'dog';
+	// 	dogType: string;
+	// }
+
+	console.log('name:', petInfo.name);
+	console.log('type:', petInfo.type);
+
+	// TypeScript complains about `catType` and `dogType` not existing on type `Cat | Dog`.
+	// @ts-expect-error
+	console.log('animal type:', petInfo.catType ?? petInfo.dogType);
+}
+
+function displayPetInfoWithAllUnionFields(petInfo: AllUnionFields<Cat | Dog>) {
+	// typeof petInfo =>
+	// {
+	// 	name: string;
+	// 	type: 'cat' | 'dog';
+	// 	catType?: string;
+	// 	dogType?: string;
+	// }
+
+	console.log('name:', petInfo.name);
+	console.log('type:', petInfo.type);
+
+	// No TypeScript error.
+	console.log('animal type:', petInfo.catType ?? petInfo.dogType);
+}
+```
+
+@see {@link SharedUnionFields}
+
+@category Object
+@category Union
+*/
+type AllUnionFields<Union> = Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends (infer SkippedMembers) ? Exclude<Union, SkippedMembers> extends (infer RelevantMembers) ?
+// eslint-disable-line @stylistic/operator-linebreak
+SkippedMembers | Simplify<
+// Include fields that are common in all union members
+SharedUnionFields<RelevantMembers> &
+// Include readonly fields present in any union member
+{ readonly [P in ReadonlyKeysOfUnion<RelevantMembers>]?: ValueOfUnion<RelevantMembers, P & KeysOfUnion<RelevantMembers>>; } &
+// Include remaining fields that are neither common nor readonly
+{ [P in Exclude<KeysOfUnion<RelevantMembers>, ReadonlyKeysOfUnion<RelevantMembers> | keyof RelevantMembers>]?: ValueOfUnion<RelevantMembers, P>; }> : never : never;
+//#endregion
+export { AllUnionFields };
+//# sourceMappingURL=all-union-fields.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/all-union-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"all-union-fields.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/all-union-fields.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsEY,eAAe,SAC1B,QAAQ,OAAO,mBAAmB,gCAAgC,uBAAuB,6BAA4B,kBAClH,QAAQ,OAAO,+BAA8B;;AAE5C,iBACA;;AAED,kBAAkB;;YAGP,KAAK,oBAAoB,oBAAoB,aAAa,iBAAiB,IAAI,YAAY;;GAIpG,KAAK,QAAQ,YAAY,kBAAkB,oBAAoB,yBAAyB,oBAAoB,aAAa,iBAAiB"}

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/internal/object.d.ts

@@ -0,0 +1,37 @@
+import { KeysOfUnion } from "../keys-of-union.js";
+import { IsEqual } from "../is-equal.js";
+//#region node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/internal/object.d.ts
+/**
+Extract all possible values for a given key from a union of object types.
+
+@example
+```
+type Statuses = ValueOfUnion<{id: 1; status: 'open'} | {id: 2; status: 'closed'}, 'status'>;
+//=> "open" | "closed"
+```
+*/
+type ValueOfUnion<Union, Key extends KeysOfUnion<Union>> = Union extends unknown ? Key extends keyof Union ? Union[Key] : never : never;
+/**
+Extract all readonly keys from a union of object types.
+
+@example
+```
+type User = {
+	readonly id: string;
+	name: string;
+};
+
+type Post = {
+	readonly id: string;
+	readonly author: string;
+	body: string;
+};
+
+type ReadonlyKeys = ReadonlyKeysOfUnion<User | Post>;
+//=> "id" | "author"
+```
+*/
+type ReadonlyKeysOfUnion<Union> = Union extends unknown ? keyof { [Key in keyof Union as IsEqual<{ [K in Key]: Union[Key]; }, { readonly [K in Key]: Union[Key]; }> extends true ? Key : never]: never; } : never;
+//#endregion
+export { ReadonlyKeysOfUnion, ValueOfUnion };
+//# sourceMappingURL=object.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/internal/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","names":[],"sources":["../../../../../../../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/internal/object.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;KA8IY,aAAa,OAAO,YAAY,YAAY,UACvD,wBAAwB,kBAAkB,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;KAsB7C,oBAAoB,SAAS,iCACvC,aAAa,SAAS,WAAU,KAAK,MAAM,MAAM,qBAAkB,KAAK,MAAM,MAAM,wBAAsB"}

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/internal/type.d.ts

@@ -0,0 +1,13 @@
+import { Primitive } from "../primitive.js";
+//#region node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/internal/type.d.ts
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+type BuiltIns = Primitive | void | Date | RegExp;
+/**
+Matches non-recursive types.
+*/
+type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown) | Promise<unknown>;
+//#endregion
+export { BuiltIns, NonRecursiveType };
+//# sourceMappingURL=type.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/internal/type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.d.ts","names":[],"sources":["../../../../../../../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/internal/type.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;KAQY,WAAW,mBAAmB,OAAO;;;;KAKrC,mBAAmB,WAAW,oBAAoB,iCAAiC"}

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-equal.d.ts

@@ -0,0 +1,33 @@
+//#region node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-equal.d.ts
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : false;
+// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
+type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
+//#endregion
+export { IsEqual };
+//# sourceMappingURL=is-equal.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-equal.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-equal.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;KA0BY,QAAQ,GAAG,MACrB,YAAY,MACT,YAAY,KACZ,SAAS,GAAG;;KAKZ,SAAS,GAAG,OACd,QAAQ,UAAU,IAAI,IAAI,qBAC1B,QAAQ,UAAU,IAAI,IAAI"}

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-never.d.ts

@@ -0,0 +1,58 @@
+//#region node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-never.d.ts
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+type A = IsNever<never>;
+//=> true
+
+type B = IsNever<any>;
+//=> false
+
+type C = IsNever<unknown>;
+//=> false
+
+type D = IsNever<never[]>;
+//=> false
+
+type E = IsNever<object>;
+//=> false
+
+type F = IsNever<string>;
+//=> false
+```
+
+@example
+```
+import type {IsNever} from 'type-fest';
+
+type IsTrue<T> = T extends true ? true : false;
+
+// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
+type A = IsTrue<never>;
+//=> never
+
+// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
+type IsTrueFixed<T> =
+	IsNever<T> extends true ? false : T extends true ? true : false;
+
+type B = IsTrueFixed<never>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+//#endregion
+export { IsNever };
+//# sourceMappingURL=is-never.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-never.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-never.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-never.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqDY,QAAQ,MAAM"}

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/keys-of-union.d.ts

@@ -0,0 +1,45 @@
+import { UnionToIntersection } from "./union-to-intersection.js";
+//#region node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/keys-of-union.d.ts
+/**
+Create a union of all keys from a given type, even those exclusive to specific union members.
+
+Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
+
+@link https://stackoverflow.com/a/49402091
+
+@example
+```
+import type {KeysOfUnion} from 'type-fest';
+
+type A = {
+	common: string;
+	a: number;
+};
+
+type B = {
+	common: string;
+	b: string;
+};
+
+type C = {
+	common: string;
+	c: boolean;
+};
+
+type Union = A | B | C;
+
+type CommonKeys = keyof Union;
+//=> 'common'
+
+type AllKeys = KeysOfUnion<Union>;
+//=> 'common' | 'a' | 'b' | 'c'
+```
+
+@category Object
+*/
+type KeysOfUnion<ObjectType> =
+// Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
+//#endregion
+export { KeysOfUnion };
+//# sourceMappingURL=keys-of-union.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/keys-of-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys-of-union.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/keys-of-union.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuCY,YAAY;;MAEjB,oBAAoB,6BAA6B,aAAa"}

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/primitive.d.ts

@@ -0,0 +1,10 @@
+//#region node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/primitive.d.ts
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+//#endregion
+export { Primitive };
+//# sourceMappingURL=primitive.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/primitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitive.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/primitive.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;KAKY"}

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/shared-union-fields.d.ts

@@ -0,0 +1,72 @@
+import { IsNever } from "./is-never.js";
+import { UnknownArray } from "./unknown-array.js";
+import { NonRecursiveType } from "./internal/type.js";
+import { Simplify } from "./simplify.js";
+//#region node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/shared-union-fields.d.ts
+/**
+Create a type with shared fields from a union of object types.
+
+Use-cases:
+- You want a safe object type where each key exists in the union object.
+- You want to focus on the common fields of the union type and don't want to have to care about the other fields.
+
+@example
+```
+import type {SharedUnionFields} from 'type-fest';
+
+type Cat = {
+	name: string;
+	type: 'cat';
+	catType: string;
+};
+
+type Dog = {
+	name: string;
+	type: 'dog';
+	dogType: string;
+};
+
+function displayPetInfo(petInfo: Cat | Dog) {
+	// typeof petInfo =>
+	// {
+	// 	name: string;
+	// 	type: 'cat';
+	// 	catType: string; // Needn't care about this field, because it's not a common pet info field.
+	// } | {
+	// 	name: string;
+	// 	type: 'dog';
+	// 	dogType: string; // Needn't care about this field, because it's not a common pet info field.
+	// }
+
+	// petInfo type is complex and have some needless fields
+
+	console.log('name:', petInfo.name);
+	console.log('type:', petInfo.type);
+}
+
+function displayPetInfoWithSharedUnionFields(petInfo: SharedUnionFields<Cat | Dog>) {
+	// typeof petInfo =>
+	// {
+	// 	name: string;
+	// 	type: 'cat' | 'dog';
+	// }
+
+	// petInfo type is simple and clear
+
+	console.log('name:', petInfo.name);
+	console.log('type:', petInfo.type);
+}
+```
+
+@see {@link SharedUnionFieldsDeep}
+@see {@link AllUnionFields}
+
+@category Object
+@category Union
+*/
+type SharedUnionFields<Union> = Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends (infer SkippedMembers) ? Exclude<Union, SkippedMembers> extends (infer RelevantMembers) ?
+// eslint-disable-line @stylistic/operator-linebreak
+SkippedMembers | (IsNever<RelevantMembers> extends true ? never : Simplify<Pick<RelevantMembers, keyof RelevantMembers>>) : never : never;
+//#endregion
+export { SharedUnionFields };
+//# sourceMappingURL=shared-union-fields.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/shared-union-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-union-fields.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/shared-union-fields.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmEY,kBAAkB,SAC7B,QAAQ,OAAO,mBAAmB,gCAAgC,uBAAuB,6BAA4B,kBAClH,QAAQ,OAAO,+BAA8B;;AAE5C,kBACC,QAAQ,wCAER,SAAS,KAAK,uBAAuB"}

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/simplify.d.ts

@@ -0,0 +1,63 @@
+//#region node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/simplify.d.ts
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+declare function fn(object: Record<string, unknown>): void;
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+// @ts-expect-error
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see {@link SimplifyDeep}
+@category Object
+*/
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType]; } & {};
+//#endregion
+export { Simplify };
+//# sourceMappingURL=simplify.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/simplify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplify.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/simplify.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA0DY,SAAS,QAAO,iBAAiB,IAAI,EAAE"}

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/union-to-intersection.d.ts

@@ -0,0 +1,36 @@
+//#region node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/union-to-intersection.d.ts
+/**
+Convert a union type to an intersection type.
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void} & {great(arg: string): void} & {escape: boolean}
+```
+
+@category Type
+*/
+type UnionToIntersection<Union> = (
+// `extends unknown` is always going to be the case and is used to convert the
+// `Union` into a [distributive conditional
+// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+Union extends unknown ?
+// The union type is used as the only argument to a function since the union
+// of function arguments is an intersection.
+(distributedUnion: Union) => void :
+// This won't happen.
+never
+// Infer the `Intersection` type since TypeScript represents the positional
+// arguments of unions of functions as an intersection of the union.
+) extends ((mergedIntersection: infer Intersection) => void) ?
+// The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
+Intersection & Union : never;
+//#endregion
+export { UnionToIntersection };
+//# sourceMappingURL=union-to-intersection.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/union-to-intersection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union-to-intersection.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/union-to-intersection.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;KAiBY,oBAAoB;;;;AAI/B;;;CAGI,kBAAkB;;;;;YAKX,0BAA0B;;AAEnC,eAAe"}

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/unknown-array.d.ts

@@ -0,0 +1,29 @@
+//#region node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/unknown-array.d.ts
+/**
+Represents an array with `unknown` value.
+
+Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
+
+@example
+```
+import type {UnknownArray} from 'type-fest';
+
+type IsArray<T> = T extends UnknownArray ? true : false;
+
+type A = IsArray<['foo']>;
+//=> true
+
+type B = IsArray<readonly number[]>;
+//=> true
+
+type C = IsArray<string>;
+//=> false
+```
+
+@category Type
+@category Array
+*/
+type UnknownArray = readonly unknown[];
+//#endregion
+export { UnknownArray };
+//# sourceMappingURL=unknown-array.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/unknown-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unknown-array.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/unknown-array.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;KAwBY"}

package/dist/peppol-validations/add-piva.d.ts

@@ -0,0 +1,8 @@
+//#region src/peppol-validations/add-piva.d.ts
+/**
+ * @description Helper function for calculating weighted sum for Italian PIVA validation.
+ */
+declare function addPIVA(arg: string, pari: number): number;
+//#endregion
+export { addPIVA };
+//# sourceMappingURL=add-piva.d.ts.map

package/dist/peppol-validations/add-piva.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-piva.d.ts","names":[],"sources":["../../src/peppol-validations/add-piva.ts"],"mappings":";;;;iBAKgB,QAAQ,aAAa"}

package/dist/peppol-validations/add-piva.js

@@ -0,0 +1,15 @@
+//#region src/peppol-validations/add-piva.ts
+/**
+* @description Helper function for calculating weighted sum for Italian PIVA validation.
+*/
+function addPIVA(arg, pari) {
+	if (!/^\d+$/.test(arg)) return 0;
+	const first = Number(arg[0]);
+	const mapper = pari === 1 ? Number("0246813579"[first]) : first;
+	if (arg.length === 1) return mapper;
+	return mapper + addPIVA(arg.slice(1), pari === 0 ? 1 : 0);
+}
+//#endregion
+export { addPIVA };
+
+//# sourceMappingURL=add-piva.js.map

package/dist/peppol-validations/add-piva.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-piva.js","names":[],"sources":["../../src/peppol-validations/add-piva.ts"],"sourcesContent":["// NOTE: check and add valid values for the tests in `add-piva.spec.ts`\n\n/**\n * @description Helper function for calculating weighted sum for Italian PIVA validation.\n */\nexport function addPIVA(arg: string, pari: number): number {\n  if (!/^\\d+$/.test(arg)) return 0;\n  const first = Number(arg[0]);\n  const mapper = pari === 1 ? Number('0246813579'[first]) : first;\n  if (arg.length === 1) return mapper;\n  return mapper + addPIVA(arg.slice(1), pari === 0 ? 1 : 0);\n}\n"],"mappings":";;;;AAKA,SAAgB,QAAQ,KAAa,MAAsB;CACzD,IAAI,CAAC,QAAQ,KAAK,GAAG,GAAG,OAAO;CAC/B,MAAM,QAAQ,OAAO,IAAI,EAAE;CAC3B,MAAM,SAAS,SAAS,IAAI,OAAO,aAAa,MAAM,IAAI;CAC1D,IAAI,IAAI,WAAW,GAAG,OAAO;CAC7B,OAAO,SAAS,QAAQ,IAAI,MAAM,CAAC,GAAG,SAAS,IAAI,IAAI,CAAC;AAC1D"}

package/dist/peppol-validations/check-cf.d.ts

@@ -0,0 +1,8 @@
+//#region src/peppol-validations/check-cf.d.ts
+/**
+ * @description Validates both 16 and 11 character Italian fiscal codes.
+ */
+declare function checkCF(arg: string): boolean;
+//#endregion
+export { checkCF };
+//# sourceMappingURL=check-cf.d.ts.map

package/dist/peppol-validations/check-cf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-cf.d.ts","names":[],"sources":["../../src/peppol-validations/check-cf.ts"],"mappings":";;;;iBAMgB,QAAQ"}