dataiku-sdk 0.2.0 → 0.2.2

package/node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-result.d.mts

@@ -0,0 +1,11 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TExtends } from './extends.mjs';
+type TFromProperties<P extends TProperties, Right extends TSchema, False extends TSchema, True extends TSchema> = ({
+    [K2 in keyof P]: TExtends<P[K2], Right, False, True>;
+});
+type TFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema> = (TFromProperties<Left['properties'], Right, True, False>);
+export type TExtendsFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema, P extends TProperties = TFromMappedResult<Left, Right, True, False>> = (TMappedResult<P>);
+export declare function ExtendsFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema, P extends TProperties = TFromMappedResult<Left, Right, True, False>>(Left: Left, Right: Right, True: True, False: False, options?: SchemaOptions): TMappedResult<P>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-result.mjs

@@ -0,0 +1,19 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Extends } from './extends.mjs';
+import { Clone } from '../clone/value.mjs';
+// prettier-ignore
+function FromProperties(P, Right, True, False, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Extends(P[K2], Right, True, False, Clone(options));
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult(Left, Right, True, False, options) {
+    return FromProperties(Left.properties, Right, True, False, options);
+}
+// prettier-ignore
+export function ExtendsFromMappedResult(Left, Right, True, False, options) {
+    const P = FromMappedResult(Left, Right, True, False, options);
+    return MappedResult(P);
+}

package/node_modules/@sinclair/typebox/build/esm/type/extends/extends-undefined.d.mts

@@ -0,0 +1,3 @@
+import type { TSchema } from '../schema/index.mjs';
+/** Fast undefined check used for properties of type undefined */
+export declare function ExtendsUndefinedCheck(schema: TSchema): boolean;

package/node_modules/@sinclair/typebox/build/esm/type/extends/extends-undefined.mjs

@@ -0,0 +1,20 @@
+import { Kind } from '../symbols/index.mjs';
+/** Fast undefined check used for properties of type undefined */
+function Intersect(schema) {
+    return schema.allOf.every((schema) => ExtendsUndefinedCheck(schema));
+}
+function Union(schema) {
+    return schema.anyOf.some((schema) => ExtendsUndefinedCheck(schema));
+}
+function Not(schema) {
+    return !ExtendsUndefinedCheck(schema.not);
+}
+/** Fast undefined check used for properties of type undefined */
+// prettier-ignore
+export function ExtendsUndefinedCheck(schema) {
+    return (schema[Kind] === 'Intersect' ? Intersect(schema) :
+        schema[Kind] === 'Union' ? Union(schema) :
+            schema[Kind] === 'Not' ? Not(schema) :
+                schema[Kind] === 'Undefined' ? true :
+                    false);
+}

package/node_modules/@sinclair/typebox/build/esm/type/extends/extends.d.mts

@@ -0,0 +1,16 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { TMappedKey, TMappedResult } from '../mapped/index.mjs';
+import { UnionToTuple } from '../helpers/index.mjs';
+import { type TExtendsFromMappedKey } from './extends-from-mapped-key.mjs';
+import { type TExtendsFromMappedResult } from './extends-from-mapped-result.mjs';
+type TExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = ((Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ? UnionToTuple<O> extends [infer X extends TSchema, infer Y extends TSchema] ? TUnion<[X, Y]> : O : never);
+export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema> = TExtendsResolve<L, R, T, F>;
+/** `[Json]` Creates a Conditional type */
+export declare function Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>;
+/** `[Json]` Creates a Conditional type */
+export declare function Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedKey<L, R, T, F>;
+/** `[Json]` Creates a Conditional type */
+export declare function Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/extends/extends.mjs

@@ -0,0 +1,23 @@
+import { CreateType } from '../create/type.mjs';
+import { Union } from '../union/index.mjs';
+import { ExtendsCheck, ExtendsResult } from './extends-check.mjs';
+import { ExtendsFromMappedKey } from './extends-from-mapped-key.mjs';
+import { ExtendsFromMappedResult } from './extends-from-mapped-result.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsMappedKey, IsMappedResult } from '../guard/kind.mjs';
+// prettier-ignore
+function ExtendsResolve(left, right, trueType, falseType) {
+    const R = ExtendsCheck(left, right);
+    return (R === ExtendsResult.Union ? Union([trueType, falseType]) :
+        R === ExtendsResult.True ? trueType :
+            falseType);
+}
+/** `[Json]` Creates a Conditional type */
+export function Extends(L, R, T, F, options) {
+    // prettier-ignore
+    return (IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T, F, options) :
+        IsMappedKey(L) ? CreateType(ExtendsFromMappedKey(L, R, T, F, options)) :
+            CreateType(ExtendsResolve(L, R, T, F), options));
+}

package/node_modules/@sinclair/typebox/build/esm/type/extends/index.d.mts

@@ -0,0 +1,5 @@
+export * from './extends-check.mjs';
+export * from './extends-from-mapped-key.mjs';
+export * from './extends-from-mapped-result.mjs';
+export * from './extends-undefined.mjs';
+export * from './extends.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/extends/index.mjs

@@ -0,0 +1,5 @@
+export * from './extends-check.mjs';
+export * from './extends-from-mapped-key.mjs';
+export * from './extends-from-mapped-result.mjs';
+export * from './extends-undefined.mjs';
+export * from './extends.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-mapped-result.d.mts

@@ -0,0 +1,11 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TExtract } from './extract.mjs';
+type TFromProperties<P extends TProperties, T extends TSchema> = ({
+    [K2 in keyof P]: TExtract<P[K2], T>;
+});
+type TFromMappedResult<R extends TMappedResult, T extends TSchema> = (TFromProperties<R['properties'], T>);
+export type TExtractFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>> = (TMappedResult<P>);
+export declare function ExtractFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T): TMappedResult<P>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-mapped-result.mjs

@@ -0,0 +1,18 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Extract } from './extract.mjs';
+// prettier-ignore
+function FromProperties(P, T) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Extract(P[K2], T);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult(R, T) {
+    return FromProperties(R.properties, T);
+}
+// prettier-ignore
+export function ExtractFromMappedResult(R, T) {
+    const P = FromMappedResult(R, T);
+    return MappedResult(P);
+}

package/node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-template-literal.d.mts

@@ -0,0 +1,5 @@
+import type { TSchema } from '../schema/index.mjs';
+import { type TExtract } from './extract.mjs';
+import { type TTemplateLiteral, type TTemplateLiteralToUnion } from '../template-literal/index.mjs';
+export type TExtractFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (TExtract<TTemplateLiteralToUnion<L>, R>);
+export declare function ExtractFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema>(L: L, R: R): TExtractFromTemplateLiteral<L, R>;

package/node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-template-literal.mjs

@@ -0,0 +1,5 @@
+import { Extract } from './extract.mjs';
+import { TemplateLiteralToUnion } from '../template-literal/index.mjs';
+export function ExtractFromTemplateLiteral(L, R) {
+    return Extract(TemplateLiteralToUnion(L), R);
+}

package/node_modules/@sinclair/typebox/build/esm/type/extract/extract.d.mts

@@ -0,0 +1,21 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { AssertRest, AssertType, UnionToTuple } from '../helpers/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type Static } from '../static/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TUnionEvaluated } from '../union/index.mjs';
+import { type TTemplateLiteral } from '../template-literal/index.mjs';
+import { type TExtractFromMappedResult } from './extract-from-mapped-result.mjs';
+import { type TExtractFromTemplateLiteral } from './extract-from-template-literal.mjs';
+type TExtractRest<L extends TSchema[], R extends TSchema> = AssertRest<UnionToTuple<{
+    [K in keyof L]: Static<AssertType<L[K]>> extends Static<R> ? L[K] : never;
+}[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never;
+export type TExtract<L extends TSchema, U extends TSchema> = (L extends TUnion<infer S> ? TExtractRest<S, U> : L extends U ? L : TNever);
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+export declare function Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+export declare function Extract<L extends TTemplateLiteral, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromTemplateLiteral<L, R>;
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+export declare function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/extract/extract.mjs

@@ -0,0 +1,25 @@
+import { CreateType } from '../create/type.mjs';
+import { Union } from '../union/index.mjs';
+import { Never } from '../never/index.mjs';
+import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
+import { ExtractFromMappedResult } from './extract-from-mapped-result.mjs';
+import { ExtractFromTemplateLiteral } from './extract-from-template-literal.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/kind.mjs';
+function ExtractRest(L, R) {
+    const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
+    return extracted.length === 1 ? extracted[0] : Union(extracted);
+}
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+export function Extract(L, R, options) {
+    // overloads
+    if (IsTemplateLiteral(L))
+        return CreateType(ExtractFromTemplateLiteral(L, R), options);
+    if (IsMappedResult(L))
+        return CreateType(ExtractFromMappedResult(L, R), options);
+    // prettier-ignore
+    return CreateType(IsUnion(L) ? ExtractRest(L.anyOf, R) :
+        ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
+}

package/node_modules/@sinclair/typebox/build/esm/type/extract/index.d.mts

@@ -0,0 +1,3 @@
+export * from './extract-from-mapped-result.mjs';
+export * from './extract-from-template-literal.mjs';
+export * from './extract.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/extract/index.mjs

@@ -0,0 +1,3 @@
+export * from './extract-from-mapped-result.mjs';
+export * from './extract-from-template-literal.mjs';
+export * from './extract.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/function/function.d.mts

@@ -0,0 +1,23 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import type { Ensure } from '../helpers/index.mjs';
+import type { TReadonlyOptional } from '../readonly-optional/index.mjs';
+import type { TReadonly } from '../readonly/index.mjs';
+import type { TOptional } from '../optional/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+type StaticReturnType<U extends TSchema, P extends unknown[]> = Static<U, P>;
+type StaticParameter<T extends TSchema, P extends unknown[]> = T extends TReadonlyOptional<T> ? [Readonly<Static<T, P>>?] : T extends TReadonly<T> ? [Readonly<Static<T, P>>] : T extends TOptional<T> ? [Static<T, P>?] : [
+    Static<T, P>
+];
+type StaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? StaticParameters<R, P, [...Acc, ...StaticParameter<L, P>]> : Acc);
+type StaticFunction<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<(...param: StaticParameters<T, P>) => StaticReturnType<U, P>>;
+export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Function';
+    static: StaticFunction<T, U, this['params']>;
+    type: 'Function';
+    parameters: T;
+    returns: U;
+}
+/** `[JavaScript]` Creates a Function type */
+export declare function Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/function/function.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a Function type */
+export function Function(parameters, returns, options) {
+    return CreateType({ [Kind]: 'Function', type: 'Function', parameters, returns }, options);
+}

package/node_modules/@sinclair/typebox/build/esm/type/function/index.d.mts

@@ -0,0 +1 @@
+export * from './function.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/function/index.mjs

@@ -0,0 +1 @@
+export * from './function.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/guard/index.d.mts

@@ -0,0 +1,3 @@
+export * as KindGuard from './kind.mjs';
+export * as TypeGuard from './type.mjs';
+export * as ValueGuard from './value.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/guard/index.mjs

@@ -0,0 +1,3 @@
+export * as KindGuard from './kind.mjs';
+export * as TypeGuard from './type.mjs';
+export * as ValueGuard from './value.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/guard/kind.d.mts

@@ -0,0 +1,147 @@
+import { Kind, Hint, TransformKind } from '../symbols/index.mjs';
+import { TransformOptions } from '../transform/index.mjs';
+import type { TAny } from '../any/index.mjs';
+import type { TArgument } from '../argument/index.mjs';
+import type { TArray } from '../array/index.mjs';
+import type { TAsyncIterator } from '../async-iterator/index.mjs';
+import type { TBoolean } from '../boolean/index.mjs';
+import type { TComputed } from '../computed/index.mjs';
+import type { TBigInt } from '../bigint/index.mjs';
+import type { TConstructor } from '../constructor/index.mjs';
+import type { TFunction } from '../function/index.mjs';
+import type { TImport } from '../module/index.mjs';
+import type { TInteger } from '../integer/index.mjs';
+import type { TIntersect } from '../intersect/index.mjs';
+import type { TIterator } from '../iterator/index.mjs';
+import type { TLiteral, TLiteralValue } from '../literal/index.mjs';
+import type { TMappedKey, TMappedResult } from '../mapped/index.mjs';
+import type { TNever } from '../never/index.mjs';
+import type { TNot } from '../not/index.mjs';
+import type { TNull } from '../null/index.mjs';
+import type { TNumber } from '../number/index.mjs';
+import type { TObject, TProperties } from '../object/index.mjs';
+import type { TOptional } from '../optional/index.mjs';
+import type { TPromise } from '../promise/index.mjs';
+import type { TReadonly } from '../readonly/index.mjs';
+import type { TRecord } from '../record/index.mjs';
+import type { TRef } from '../ref/index.mjs';
+import type { TRegExp } from '../regexp/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
+import type { TString } from '../string/index.mjs';
+import type { TSymbol } from '../symbol/index.mjs';
+import type { TTemplateLiteral } from '../template-literal/index.mjs';
+import type { TTuple } from '../tuple/index.mjs';
+import type { TUint8Array } from '../uint8array/index.mjs';
+import type { TUndefined } from '../undefined/index.mjs';
+import type { TUnknown } from '../unknown/index.mjs';
+import type { TUnion } from '../union/index.mjs';
+import type { TUnsafe } from '../unsafe/index.mjs';
+import type { TVoid } from '../void/index.mjs';
+import type { TDate } from '../date/index.mjs';
+import type { TThis } from '../recursive/index.mjs';
+/** `[Kind-Only]` Returns true if this value has a Readonly symbol */
+export declare function IsReadonly<T extends TSchema>(value: T): value is TReadonly<T>;
+/** `[Kind-Only]` Returns true if this value has a Optional symbol */
+export declare function IsOptional<T extends TSchema>(value: T): value is TOptional<T>;
+/** `[Kind-Only]` Returns true if the given value is TAny */
+export declare function IsAny(value: unknown): value is TAny;
+/** `[Kind-Only]` Returns true if the given value is TArgument */
+export declare function IsArgument(value: unknown): value is TArgument;
+/** `[Kind-Only]` Returns true if the given value is TArray */
+export declare function IsArray(value: unknown): value is TArray;
+/** `[Kind-Only]` Returns true if the given value is TAsyncIterator */
+export declare function IsAsyncIterator(value: unknown): value is TAsyncIterator;
+/** `[Kind-Only]` Returns true if the given value is TBigInt */
+export declare function IsBigInt(value: unknown): value is TBigInt;
+/** `[Kind-Only]` Returns true if the given value is TBoolean */
+export declare function IsBoolean(value: unknown): value is TBoolean;
+/** `[Kind-Only]` Returns true if the given value is TComputed */
+export declare function IsComputed(value: unknown): value is TComputed;
+/** `[Kind-Only]` Returns true if the given value is TConstructor */
+export declare function IsConstructor(value: unknown): value is TConstructor;
+/** `[Kind-Only]` Returns true if the given value is TDate */
+export declare function IsDate(value: unknown): value is TDate;
+/** `[Kind-Only]` Returns true if the given value is TFunction */
+export declare function IsFunction(value: unknown): value is TFunction;
+/** `[Kind-Only]` Returns true if the given value is TInteger */
+export declare function IsImport(value: unknown): value is TImport;
+/** `[Kind-Only]` Returns true if the given value is TInteger */
+export declare function IsInteger(value: unknown): value is TInteger;
+/** `[Kind-Only]` Returns true if the given schema is TProperties */
+export declare function IsProperties(value: unknown): value is TProperties;
+/** `[Kind-Only]` Returns true if the given value is TIntersect */
+export declare function IsIntersect(value: unknown): value is TIntersect;
+/** `[Kind-Only]` Returns true if the given value is TIterator */
+export declare function IsIterator(value: unknown): value is TIterator;
+/** `[Kind-Only]` Returns true if the given value is a TKind with the given name. */
+export declare function IsKindOf<T extends string>(value: unknown, kind: T): value is Record<PropertyKey, unknown> & {
+    [Kind]: T;
+};
+/** `[Kind-Only]` Returns true if the given value is TLiteral<string> */
+export declare function IsLiteralString(value: unknown): value is TLiteral<string>;
+/** `[Kind-Only]` Returns true if the given value is TLiteral<number> */
+export declare function IsLiteralNumber(value: unknown): value is TLiteral<number>;
+/** `[Kind-Only]` Returns true if the given value is TLiteral<boolean> */
+export declare function IsLiteralBoolean(value: unknown): value is TLiteral<boolean>;
+/** `[Kind-Only]` Returns true if the given value is TLiteralValue */
+export declare function IsLiteralValue(value: unknown): value is TLiteralValue;
+/** `[Kind-Only]` Returns true if the given value is TLiteral */
+export declare function IsLiteral(value: unknown): value is TLiteral;
+/** `[Kind-Only]` Returns true if the given value is a TMappedKey */
+export declare function IsMappedKey(value: unknown): value is TMappedKey;
+/** `[Kind-Only]` Returns true if the given value is TMappedResult */
+export declare function IsMappedResult(value: unknown): value is TMappedResult;
+/** `[Kind-Only]` Returns true if the given value is TNever */
+export declare function IsNever(value: unknown): value is TNever;
+/** `[Kind-Only]` Returns true if the given value is TNot */
+export declare function IsNot(value: unknown): value is TNot;
+/** `[Kind-Only]` Returns true if the given value is TNull */
+export declare function IsNull(value: unknown): value is TNull;
+/** `[Kind-Only]` Returns true if the given value is TNumber */
+export declare function IsNumber(value: unknown): value is TNumber;
+/** `[Kind-Only]` Returns true if the given value is TObject */
+export declare function IsObject(value: unknown): value is TObject;
+/** `[Kind-Only]` Returns true if the given value is TPromise */
+export declare function IsPromise(value: unknown): value is TPromise;
+/** `[Kind-Only]` Returns true if the given value is TRecord */
+export declare function IsRecord(value: unknown): value is TRecord;
+/** `[Kind-Only]` Returns true if this value is TRecursive */
+export declare function IsRecursive(value: unknown): value is {
+    [Hint]: 'Recursive';
+};
+/** `[Kind-Only]` Returns true if the given value is TRef */
+export declare function IsRef(value: unknown): value is TRef;
+/** `[Kind-Only]` Returns true if the given value is TRegExp */
+export declare function IsRegExp(value: unknown): value is TRegExp;
+/** `[Kind-Only]` Returns true if the given value is TString */
+export declare function IsString(value: unknown): value is TString;
+/** `[Kind-Only]` Returns true if the given value is TSymbol */
+export declare function IsSymbol(value: unknown): value is TSymbol;
+/** `[Kind-Only]` Returns true if the given value is TTemplateLiteral */
+export declare function IsTemplateLiteral(value: unknown): value is TTemplateLiteral;
+/** `[Kind-Only]` Returns true if the given value is TThis */
+export declare function IsThis(value: unknown): value is TThis;
+/** `[Kind-Only]` Returns true of this value is TTransform */
+export declare function IsTransform(value: unknown): value is {
+    [TransformKind]: TransformOptions;
+};
+/** `[Kind-Only]` Returns true if the given value is TTuple */
+export declare function IsTuple(value: unknown): value is TTuple;
+/** `[Kind-Only]` Returns true if the given value is TUndefined */
+export declare function IsUndefined(value: unknown): value is TUndefined;
+/** `[Kind-Only]` Returns true if the given value is TUnion */
+export declare function IsUnion(value: unknown): value is TUnion;
+/** `[Kind-Only]` Returns true if the given value is TUint8Array */
+export declare function IsUint8Array(value: unknown): value is TUint8Array;
+/** `[Kind-Only]` Returns true if the given value is TUnknown */
+export declare function IsUnknown(value: unknown): value is TUnknown;
+/** `[Kind-Only]` Returns true if the given value is a raw TUnsafe */
+export declare function IsUnsafe(value: unknown): value is TUnsafe<unknown>;
+/** `[Kind-Only]` Returns true if the given value is TVoid */
+export declare function IsVoid(value: unknown): value is TVoid;
+/** `[Kind-Only]` Returns true if the given value is TKind */
+export declare function IsKind(value: unknown): value is Record<PropertyKey, unknown> & {
+    [Kind]: string;
+};
+/** `[Kind-Only]` Returns true if the given value is TSchema */
+export declare function IsSchema(value: unknown): value is TSchema;