pcp-server-ruby-sdk 0.1.0 → 1.1.0

data/node_modules/type-fest/source/conditional-except.d.ts

@@ -1,45 +0,0 @@
-import type {Except} from './except';
-import type {ConditionalKeys} from './conditional-keys';
-
-/**
-Exclude keys from a shape that matches the given `Condition`.
-
-This is useful when you want to create a new type with a specific set of keys from a shape. For example, you might want to exclude all the primitive properties from a class and form a new shape containing everything but the primitive properties.
-
-@example
-```
-import type {Primitive, ConditionalExcept} from 'type-fest';
-
-class Awesome {
-	name: string;
-	successes: number;
-	failures: bigint;
-
-	run() {}
-}
-
-type ExceptPrimitivesFromAwesome = ConditionalExcept<Awesome, Primitive>;
-//=> {run: () => void}
-```
-
-@example
-```
-import type {ConditionalExcept} from 'type-fest';
-
-interface Example {
-	a: string;
-	b: string | number;
-	c: () => void;
-	d: {};
-}
-
-type NonStringKeysOnly = ConditionalExcept<Example, string>;
-//=> {b: string | number; c: () => void; d: {}}
-```
-
-@category Object
-*/
-export type ConditionalExcept<Base, Condition> = Except<
-Base,
-ConditionalKeys<Base, Condition>
->;

data/node_modules/type-fest/source/conditional-keys.d.ts

@@ -1,47 +0,0 @@
-import type {IfNever} from './if-never';
-
-/**
-Extract the keys from a type where the value type of the key extends the given `Condition`.
-
-Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
-
-@example
-```
-import type {ConditionalKeys} from 'type-fest';
-
-interface Example {
-	a: string;
-	b: string | number;
-	c?: string;
-	d: {};
-}
-
-type StringKeysOnly = ConditionalKeys<Example, string>;
-//=> 'a'
-```
-
-To support partial types, make sure your `Condition` is a union of undefined (for example, `string | undefined`) as demonstrated below.
-
-@example
-```
-import type {ConditionalKeys} from 'type-fest';
-
-type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
-//=> 'a' | 'c'
-```
-
-@category Object
-*/
-export type ConditionalKeys<Base, Condition> =
-{
-	// Map through all the keys of the given base type.
-	[Key in keyof Base]-?:
-	// Pick only keys with types extending the given `Condition` type.
-	Base[Key] extends Condition
-	// Retain this key
-	// If the value for the key extends never, only include it if `Condition` also extends never
-		? IfNever<Base[Key], IfNever<Condition, Key, never>, Key>
-	// Discard this key since the condition fails.
-		: never;
-	// Convert the produced object into a union type of the keys which passed the conditional test.
-}[keyof Base];

data/node_modules/type-fest/source/conditional-pick-deep.d.ts

@@ -1,104 +0,0 @@
-import type {IsEqual} from './is-equal';
-import type {ConditionalExcept} from './conditional-except';
-import type {ConditionalSimplifyDeep} from './conditional-simplify';
-import type {UnknownRecord} from './unknown-record';
-import type {EmptyObject} from './empty-object';
-import type {IsPlainObject} from './internal';
-
-/**
-Used to mark properties that should be excluded.
-*/
-declare const conditionalPickDeepSymbol: unique symbol;
-
-/**
-Assert the condition according to the {@link ConditionalPickDeepOptions.condition|condition} option.
-*/
-type AssertCondition<Type, Condition, Options extends ConditionalPickDeepOptions> = Options['condition'] extends 'equality'
-	? IsEqual<Type, Condition>
-	: Type extends Condition
-		? true
-		: false;
-
-/**
-ConditionalPickDeep options.
-
-@see ConditionalPickDeep
-*/
-export type ConditionalPickDeepOptions = {
-	/**
-	The condition assertion mode.
-
-	@default 'extends'
-	*/
-	condition?: 'extends' | 'equality';
-};
-
-/**
-Pick keys recursively from the shape that matches the given condition.
-
-@see ConditionalPick
-
-@example
-```
-import type {ConditionalPickDeep} from 'type-fest';
-
-interface Example {
-	a: string;
-	b: string | boolean;
-	c: {
-		d: string;
-		e: {
-			f?: string;
-			g?: boolean;
-			h: string | boolean;
-			i: boolean | bigint;
-		};
-		j: boolean;
-	};
-}
-
-type StringPick = ConditionalPickDeep<Example, string>;
-//=> {a: string; c: {d: string}}
-
-type StringPickOptional = ConditionalPickDeep<Example, string | undefined>;
-//=> {a: string; c: {d: string; e: {f?: string}}}
-
-type StringPickOptionalOnly = ConditionalPickDeep<Example, string | undefined, {condition: 'equality'}>;
-//=> {c: {e: {f?: string}}}
-
-type BooleanPick = ConditionalPickDeep<Example, boolean | undefined>;
-//=> {c: {e: {g?: boolean}; j: boolean}}
-
-type NumberPick = ConditionalPickDeep<Example, number>;
-//=> {}
-
-type StringOrBooleanPick = ConditionalPickDeep<Example, string | boolean>;
-//=> {
-// 	a: string;
-// 	b: string | boolean;
-// 	c: {
-// 		d: string;
-// 		e: {
-// 			h: string | boolean
-// 		};
-// 		j: boolean;
-// 	};
-// }
-
-type StringOrBooleanPickOnly = ConditionalPickDeep<Example, string | boolean, {condition: 'equality'}>;
-//=> {b: string | boolean; c: {e: {h: string | boolean}}}
-```
-
-@category Object
-*/
-export type ConditionalPickDeep<
-	Type,
-	Condition,
-	Options extends ConditionalPickDeepOptions = {},
-> = ConditionalSimplifyDeep<ConditionalExcept<{
-	[Key in keyof Type]: AssertCondition<Type[Key], Condition, Options> extends true
-		? Type[Key]
-		: IsPlainObject<Type[Key]> extends true
-			? ConditionalPickDeep<Type[Key], Condition, Options>
-			: typeof conditionalPickDeepSymbol;
-}, (typeof conditionalPickDeepSymbol | undefined) | EmptyObject>, never, UnknownRecord>;

data/node_modules/type-fest/source/conditional-pick.d.ts

@@ -1,44 +0,0 @@
-import type {ConditionalKeys} from './conditional-keys';
-
-/**
-Pick keys from the shape that matches the given `Condition`.
-
-This is useful when you want to create a new type from a specific subset of an existing type. For example, you might want to pick all the primitive properties from a class and form a new automatically derived type.
-
-@example
-```
-import type {Primitive, ConditionalPick} from 'type-fest';
-
-class Awesome {
-	name: string;
-	successes: number;
-	failures: bigint;
-
-	run() {}
-}
-
-type PickPrimitivesFromAwesome = ConditionalPick<Awesome, Primitive>;
-//=> {name: string; successes: number; failures: bigint}
-```
-
-@example
-```
-import type {ConditionalPick} from 'type-fest';
-
-interface Example {
-	a: string;
-	b: string | number;
-	c: () => void;
-	d: {};
-}
-
-type StringKeysOnly = ConditionalPick<Example, string>;
-//=> {a: string}
-```
-
-@category Object
-*/
-export type ConditionalPick<Base, Condition> = Pick<
-Base,
-ConditionalKeys<Base, Condition>
->;

data/node_modules/type-fest/source/conditional-simplify.d.ts

@@ -1,32 +0,0 @@
-/**
-Simplifies a type while including and/or excluding certain types from being simplified. Useful to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
-
-This type is **experimental** and was introduced as a result of this {@link https://github.com/sindresorhus/type-fest/issues/436 issue}. It should be used with caution.
-
-@internal
-@experimental
-@see Simplify
-@category Object
-*/
-export type ConditionalSimplify<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType
-	? Type
-	: Type extends IncludeType
-		? {[TypeKey in keyof Type]: Type[TypeKey]}
-		: Type;
-
-/**
-Recursively simplifies a type while including and/or excluding certain types from being simplified.
-
-This type is **experimental** and was introduced as a result of this {@link https://github.com/sindresorhus/type-fest/issues/436 issue}. It should be used with caution.
-
-See {@link ConditionalSimplify} for usages and examples.
-
-@internal
-@experimental
-@category Object
-*/
-export type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType
-	? Type
-	: Type extends IncludeType
-		? {[TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType>}
-		: Type;

data/node_modules/type-fest/source/delimiter-case.d.ts

@@ -1,99 +0,0 @@
-import type {UpperCaseCharacters, WordSeparators} from './internal';
-
-// Transforms a string that is fully uppercase into a fully lowercase version. Needed to add support for SCREAMING_SNAKE_CASE, see https://github.com/sindresorhus/type-fest/issues/385
-type UpperCaseToLowerCase<T extends string> = T extends Uppercase<T> ? Lowercase<T> : T;
-
-// This implementation does not support SCREAMING_SNAKE_CASE, it is used internally by `SplitIncludingDelimiters`.
-type SplitIncludingDelimiters_<Source extends string, Delimiter extends string> =
-	Source extends '' ? [] :
-		Source extends `${infer FirstPart}${Delimiter}${infer SecondPart}` ?
-			(
-				Source extends `${FirstPart}${infer UsedDelimiter}${SecondPart}`
-					? UsedDelimiter extends Delimiter
-						? Source extends `${infer FirstPart}${UsedDelimiter}${infer SecondPart}`
-							? [...SplitIncludingDelimiters<FirstPart, Delimiter>, UsedDelimiter, ...SplitIncludingDelimiters<SecondPart, Delimiter>]
-							: never
-						: never
-					: never
-			) :
-			[Source];
-
-/**
-Unlike a simpler split, this one includes the delimiter splitted on in the resulting array literal. This is to enable splitting on, for example, upper-case characters.
-
-@category Template literal
-*/
-export type SplitIncludingDelimiters<Source extends string, Delimiter extends string> = SplitIncludingDelimiters_<UpperCaseToLowerCase<Source>, Delimiter>;
-
-/**
-Format a specific part of the splitted string literal that `StringArrayToDelimiterCase<>` fuses together, ensuring desired casing.
-
-@see StringArrayToDelimiterCase
-*/
-type StringPartToDelimiterCase<StringPart extends string, Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
-	StringPart extends UsedWordSeparators ? Delimiter :
-		Start extends true ? Lowercase<StringPart> :
-			StringPart extends UsedUpperCaseCharacters ? `${Delimiter}${Lowercase<StringPart>}` :
-				StringPart;
-
-/**
-Takes the result of a splitted string literal and recursively concatenates it together into the desired casing.
-
-It receives `UsedWordSeparators` and `UsedUpperCaseCharacters` as input to ensure it's fully encapsulated.
-
-@see SplitIncludingDelimiters
-*/
-type StringArrayToDelimiterCase<Parts extends readonly any[], Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
-	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
-		? `${StringPartToDelimiterCase<FirstPart, Start, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}${StringArrayToDelimiterCase<RemainingParts, false, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}`
-		: Parts extends [string]
-			? string
-			: '';
-
-/**
-Convert a string literal to a custom string delimiter casing.
-
-This can be useful when, for example, converting a camel-cased object property to an oddly cased one.
-
-@see KebabCase
-@see SnakeCase
-
-@example
-```
-import type {DelimiterCase} from 'type-fest';
-
-// Simple
-
-const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
-
-// Advanced
-
-type OddlyCasedProperties<T> = {
-	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
-};
-
-interface SomeOptions {
-	dryRun: boolean;
-	includeFile: string;
-	foo: number;
-}
-
-const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
-	'dry#run': true,
-	'include#file': 'bar.js',
-	foo: 123
-};
-```
-
-@category Change case
-@category Template literal
-*/
-export type DelimiterCase<Value, Delimiter extends string> = string extends Value ? Value : Value extends string
-	? StringArrayToDelimiterCase<
-	SplitIncludingDelimiters<Value, WordSeparators | UpperCaseCharacters>,
-	true,
-	WordSeparators,
-	UpperCaseCharacters,
-	Delimiter
-	>
-	: Value;

data/node_modules/type-fest/source/delimiter-cased-properties-deep.d.ts

@@ -1,84 +0,0 @@
-import type {DelimiterCase} from './delimiter-case';
-import type {NonRecursiveType} from './internal';
-import type {UnknownArray} from './unknown-array';
-
-/**
-Convert object properties to delimiter case recursively.
-
-This can be useful when, for example, converting some API types from a different style.
-
-@see DelimiterCase
-@see DelimiterCasedProperties
-
-@example
-```
-import type {DelimiterCasedPropertiesDeep} from 'type-fest';
-
-interface User {
-	userId: number;
-	userName: string;
-}
-
-interface UserWithFriends {
-	userInfo: User;
-	userFriends: User[];
-}
-
-const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
-	'user-info': {
-	'user-id': 1,
-		'user-name': 'Tom',
-	},
-	'user-friends': [
-		{
-			'user-id': 2,
-			'user-name': 'Jerry',
-		},
-		{
-			'user-id': 3,
-			'user-name': 'Spike',
-		},
-	],
-};
-```
-
-@category Change case
-@category Template literal
-@category Object
-*/
-export type DelimiterCasedPropertiesDeep<
-	Value,
-	Delimiter extends string,
-> = Value extends NonRecursiveType
-	? Value
-	: Value extends UnknownArray
-		? DelimiterCasedPropertiesArrayDeep<Value, Delimiter>
-		: Value extends Set<infer U>
-			? Set<DelimiterCasedPropertiesDeep<U, Delimiter>> : {
-				[K in keyof Value as DelimiterCase<
-				K,
-				Delimiter
-				>]: DelimiterCasedPropertiesDeep<Value[K], Delimiter>;
-			};
-
-// This is a copy of CamelCasedPropertiesArrayDeep (see: camel-cased-properties-deep.d.ts).
-// These types should be kept in sync.
-type DelimiterCasedPropertiesArrayDeep<Value extends UnknownArray, Delimiter extends string> =
-	Value extends []
-		? []
-		// Tailing spread array
-		:	Value extends [infer U, ...infer V]
-			? [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>]
-			: Value extends readonly [infer U, ...infer V]
-				? readonly [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>]
-				// Leading spread array
-				: Value extends readonly [...infer U, infer V]
-					? [...DelimiterCasedPropertiesDeep<U, Delimiter>, DelimiterCasedPropertiesDeep<V, Delimiter>]
-					: Value extends readonly [...infer U, infer V]
-						? readonly [...DelimiterCasedPropertiesDeep<U, Delimiter>, DelimiterCasedPropertiesDeep<V, Delimiter>]
-						// Array
-						: Value extends Array<infer U>
-							? Array<DelimiterCasedPropertiesDeep<U, Delimiter>>
-							: Value extends ReadonlyArray<infer U>
-								? ReadonlyArray<DelimiterCasedPropertiesDeep<U, Delimiter>>
-								: never;

data/node_modules/type-fest/source/delimiter-cased-properties.d.ts

@@ -1,37 +0,0 @@
-import type {DelimiterCase} from './delimiter-case';
-
-/**
-Convert object properties to delimiter case but not recursively.
-
-This can be useful when, for example, converting some API types from a different style.
-
-@see DelimiterCase
-@see DelimiterCasedPropertiesDeep
-
-@example
-```
-import type {DelimiterCasedProperties} from 'type-fest';
-
-interface User {
-	userId: number;
-	userName: string;
-}
-
-const result: DelimiterCasedProperties<User, '-'> = {
-	'user-id': 1,
-	'user-name': 'Tom',
-};
-```
-
-@category Change case
-@category Template literal
-@category Object
-*/
-export type DelimiterCasedProperties<
-	Value,
-	Delimiter extends string,
-> = Value extends Function
-	? Value
-	: Value extends Array<infer U>
-		? Value
-		: {[K in keyof Value as DelimiterCase<K, Delimiter>]: Value[K]};

data/node_modules/type-fest/source/distributed-omit.d.ts

@@ -1,89 +0,0 @@
-import type {KeysOfUnion} from './keys-of-union';
-
-/**
-Omits keys from a type, distributing the operation over a union.
-
-TypeScript's `Omit` doesn't distribute over unions, leading to the erasure of unique properties from union members when omitting keys. This creates a type that only retains properties common to all union members, making it impossible to access member-specific properties after the Omit. Essentially, using `Omit` on a union type merges the types into a less specific one, hindering type narrowing and property access based on discriminants. This type solves that.
-
-Example:
-
-```
-type A = {
-	discriminant: 'A';
-	foo: string;
-	a: number;
-};
-
-type B = {
-	discriminant: 'B';
-	foo: string;
-	b: string;
-};
-
-type Union = A | B;
-
-type OmittedUnion = Omit<Union, 'foo'>;
-//=> {discriminant: 'A' | 'B'}
-
-const omittedUnion: OmittedUnion = createOmittedUnion();
-
-if (omittedUnion.discriminant === 'A') {
-	// We would like to narrow `omittedUnion`'s type
-	// to `A` here, but we can't because `Omit`
-	// doesn't distribute over unions.
-
-	omittedUnion.a;
- 	//=> Error: `a` is not a property of `{discriminant: 'A' | 'B'}`
-}
-```
-
-While `Except` solves this problem, it restricts the keys you can omit to the ones that are present in **ALL** union members, where `DistributedOmit` allows you to omit keys that are present in **ANY** union member.
-
-@example
-```
-type A = {
-	discriminant: 'A';
-	foo: string;
-	a: number;
-};
-
-type B = {
-	discriminant: 'B';
-	foo: string;
-	bar: string;
-	b: string;
-};
-
-type C = {
-	discriminant: 'C';
-	bar: string;
-	c: boolean;
-};
-
-// Notice that `foo` exists in `A` and `B`, but not in `C`, and
-// `bar` exists in `B` and `C`, but not in `A`.
-
-type Union = A | B | C;
-
-type OmittedUnion = DistributedOmit<Union, 'foo' | 'bar'>;
-
-const omittedUnion: OmittedUnion = createOmittedUnion();
-
-if (omittedUnion.discriminant === 'A') {
-	omittedUnion.a;
- 	//=> OK
-
-	omittedUnion.foo;
- 	//=> Error: `foo` is not a property of `{discriminant: 'A'; a: string}`
-
-	omittedUnion.bar;
- 	//=> Error: `bar` is not a property of `{discriminant: 'A'; a: string}`
-}
-```
-
-@category Object
-*/
-export type DistributedOmit<ObjectType, KeyType extends KeysOfUnion<ObjectType>> =
-	ObjectType extends unknown
-		? Omit<ObjectType, KeyType>
-		: never;

data/node_modules/type-fest/source/distributed-pick.d.ts

@@ -1,85 +0,0 @@
-import type {KeysOfUnion} from './keys-of-union';
-
-/**
-Pick keys from a type, distributing the operation over a union.
-
-TypeScript's `Pick` doesn't distribute over unions, leading to the erasure of unique properties from union members when picking keys. This creates a type that only retains properties common to all union members, making it impossible to access member-specific properties after the Pick. Essentially, using `Pick` on a union type merges the types into a less specific one, hindering type narrowing and property access based on discriminants. This type solves that.
-
-Example:
-
-```
-type A = {
-	discriminant: 'A';
-	foo: {
-		bar: string;
-	};
-};
-
-type B = {
-	discriminant: 'B';
-	foo: {
-		baz: string;
-	};
-};
-
-type Union = A | B;
-
-type PickedUnion = Pick<Union, 'discriminant' | 'foo'>;
-//=> {discriminant: 'A' | 'B', foo: {bar: string} | {baz: string}}
-
-const pickedUnion: PickedUnion = createPickedUnion();
-
-if (pickedUnion.discriminant === 'A') {
-	// We would like to narrow `pickedUnion`'s type
-	// to `A` here, but we can't because `Pick`
-	// doesn't distribute over unions.
-
-	pickedUnion.foo.bar;
-	//=> Error: Property 'bar' does not exist on type '{bar: string} | {baz: string}'.
-}
-```
-
-@example
-```
-type A = {
-	discriminant: 'A';
-	foo: {
-		bar: string;
-	};
-	extraneous: boolean;
-};
-
-type B = {
-	discriminant: 'B';
-	foo: {
-		baz: string;
-	};
-	extraneous: boolean;
-};
-
-// Notice that `foo.bar` exists in `A` but not in `B`.
-
-type Union = A | B;
-
-type PickedUnion = DistributedPick<Union, 'discriminant' | 'foo'>;
-
-const pickedUnion: PickedUnion = createPickedUnion();
-
-if (pickedUnion.discriminant === 'A') {
-	pickedUnion.foo.bar;
- 	//=> OK
-
-	pickedUnion.extraneous;
-	//=> Error: Property `extraneous` does not exist on type `Pick<A, 'discriminant' | 'foo'>`.
-
-	pickedUnion.foo.baz;
-	//=> Error: `bar` is not a property of `{discriminant: 'A'; a: string}`.
-}
-```
-
-@category Object
-*/
-export type DistributedPick<ObjectType, KeyType extends KeysOfUnion<ObjectType>> =
-	ObjectType extends unknown
-		? Pick<ObjectType, Extract<KeyType, keyof ObjectType>>
-		: never;