@endevops/peppol-schema 0.1.0-beta.4 → 0.1.0-beta.5

package/dist/all-union-fields-CxoyKBpI.d.ts

@@ -1,445 +0,0 @@
-//#region node_modules/.pnpm/type-fest@5.9.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
-//#region node_modules/.pnpm/type-fest@5.9.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
-//#region node_modules/.pnpm/type-fest@5.9.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
-//#region node_modules/.pnpm/type-fest@5.9.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
-//#region node_modules/.pnpm/type-fest@5.9.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
-//#region node_modules/.pnpm/type-fest@5.9.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
-//#region node_modules/.pnpm/type-fest@5.9.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
-//#region node_modules/.pnpm/type-fest@5.9.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
-//#region node_modules/.pnpm/type-fest@5.9.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
-//#region node_modules/.pnpm/type-fest@5.9.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
-//#region node_modules/.pnpm/type-fest@5.9.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 as t };
-//# sourceMappingURL=all-union-fields-CxoyKBpI.d.ts.map

package/dist/all-union-fields-CxoyKBpI.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"all-union-fields-CxoyKBpI.d.ts","names":[],"sources":["../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/primitive.d.ts","../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/union-to-intersection.d.ts","../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/keys-of-union.d.ts","../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-never.d.ts","../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/unknown-array.d.ts","../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/type.d.ts","../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/simplify.d.ts","../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-equal.d.ts","../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/object.d.ts","../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/shared-union-fields.d.ts","../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/all-union-fields.d.ts"],"x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10],"mappings":";;;;;;KAKY;;;;;;;;;;;;;;;;;;;;KCYA,oBAAoB;;;;AAI/B;;;CAGI,kBAAkB;;;;;YAKX,0BAA0B;;AAEnC,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCQN,YAAY;;MAEjB,oBAAoB,6BAA6B,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCYzD,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;KC7Bd;;;;;;KChBA,WAAW,mBAAmB,OAAO;;;;KAKrC,mBAAmB,WAAW,oBAAoB,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KC6CnF,SAAS,QAAO,iBAAiB,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KChCvC,QAAQ,GAAG,MACrB,YAAY,MACT,YAAY,KACZ,SAAS,GAAG;;KAKZ,SAAS,GAAG,OACd,QAAQ,UAAU,IAAI,IAAI,qBAC1B,QAAQ,UAAU,IAAI,IAAI;;;;;;;;;;;;KC2GjB,aAAa,OAAO,YAAY,YAAY,UACvD,wBAAwB,kBAAkB,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;KAsB7C,oBAAoB,SAAS,iCACvC,aAAa,SAAS,WAAU,KAAK,MAAM,MAAM,qBAAkB,KAAK,MAAM,MAAM,wBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCpGhG,kBAAkB,SAC7B,QAAQ,OAAO,mBAAmB,gCAAgC,uBAAuB,6BAA4B,kBAClH,QAAQ,OAAO,+BAA8B;;AAE5C,kBACC,QAAQ,wCAER,SAAS,KAAK,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCJ/B,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"}