Options
All
  • Public
  • Public/Protected
  • All
Menu

Namespace <internal>

Index

Namespaces

Enumerations

Enumeration members

Classes

Interfaces

Type aliases

Variables

Enumeration members

Mapping

Mapping = "mapping"

Tag

Tag = "tag"

Type aliases

AdditionalItemsError

AdditionalItemsError: ErrorObject<"additionalItems", { limit: number }, AnySchema>

AdditionalPropertiesError

AdditionalPropertiesError: ErrorObject<"additionalProperties", { additionalProperty: string }, AnySchema>

AnyOfError

AnyOfError: ErrorNoParams<"anyOf", AnySchema[]>

AnySchema

AnySchema: Schema | AsyncSchema

AnySchemaObject

AnySchemaObject: SchemaObject | AsyncSchema

AnyValidateFunction

AnyValidateFunction<T>: ValidateFunction<T> | AsyncValidateFunction<T>

Type parameters

  • T = any

ApplicatorKeywordError

ApplicatorKeywordError: ErrorNoParams<"false schema"> | AdditionalItemsError | ItemsError | ContainsError | AdditionalPropertiesError | DependenciesError | IfKeywordError | AnyOfError | OneOfError | NotKeywordError | PropertyNamesError

ArrayBufferLike

ArrayBufferLike: ArrayBufferTypes[keyof ArrayBufferTypes]

ArrayBufferView

ArrayBufferView: TypedArray | DataView

AwaitIterable

AwaitIterable<T>: Iterable<T> | AsyncIterable<T>

Type parameters

  • T

Block

Block: { bytes: Uint8Array; cid: CID }

Type declaration

  • bytes: Uint8Array
  • cid: CID

BufferEncoding

BufferEncoding: "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex"

ByteView

ByteView<T>: "/home/runner/work/metaplex-auth/metaplex-auth/node_modules/multiformats/types/src/codecs/interface"

Type parameters

  • T

ByteView

ByteView<T>: Uint8Array | (Uint8Array & { data: T })

Type parameters

  • T

CIDString

CIDString: <internal>.Tagged<string, CID>

CID in string representation

CIDVersion

CIDVersion: 0 | 1

CarReader

CarReader: "/home/runner/work/metaplex-auth/metaplex-auth/node_modules/nft.storage/dist/src/lib/interface"

Code

Code: _Code | Name

CodeItem

CodeItem: Name | string | number | boolean | null

Comparison

Comparison: "<=" | ">=" | "<" | ">"

ConstError

ConstError: ErrorObject<"const", { allowedValue: any }>

ContainsError

ContainsError: ErrorObject<"contains", { maxContains?: number; minContains: number }, AnySchema>

DefinedError

DefinedError: TypeError | ApplicatorKeywordError | ValidationKeywordError | FormatError | UnevaluatedPropertiesError | UnevaluatedItemsError | DependentRequiredError | DiscriminatorError

DependenciesError

DependenciesError: ErrorObject<"dependencies", DependenciesErrorParams, { [ K in string]?: string[] | AnySchema }>

DependentRequiredError

DependentRequiredError: ErrorObject<"dependentRequired", DependenciesErrorParams, PropertyDependencies>

DiscrErrorObj

DiscrErrorObj<E>: ErrorObject<"discriminator", { error: E; tag: string; tagValue: unknown }, string>

Type parameters

DiscriminatorError

DiscriminatorError: DiscrErrorObj<Tag> | DiscrErrorObj<Mapping>

EnumError

EnumError: ErrorObject<"enum", { allowedValues: any[] }, any[] | { $data: string }>

ErrorNoParams

ErrorNoParams<K, S>: ErrorObject<K, Record<string, never>, S>

Type parameters

  • K: string

  • S = unknown

EvaluatedItems

EvaluatedItems: number | true

EvaluatedProperties

EvaluatedProperties: { [ K in string]?: true } | true

Exclude

Exclude<T, U>: T extends U ? never : T

Exclude from T those types that are assignable to U

Type parameters

  • T

  • U

FormatError

FormatError: ErrorObject<"format", { format: string }, string | { $data: string }>

IfKeywordError

IfKeywordError: ErrorObject<"if", { failingKeyword: string }, AnySchema>

ItemsError

ItemsError: ErrorObject<"items", { limit: number }, AnySchema>

IteratorResult

IteratorResult<T, TReturn>: IteratorYieldResult<T> | IteratorReturnResult<TReturn>

Type parameters

  • T

  • TReturn = any

JSONSchemaType

JSONSchemaType<T>: StrictNullChecksWrapper<"JSONSchemaType", UncheckedJSONSchemaType<T, false>>

Type parameters

  • T

JSONType

JSONType<T, IsPartial>: IsPartial extends true ? T | undefined : T

Type parameters

  • T: string

  • IsPartial: boolean

Known

Known: {} | [Known, ...Known[]] | Known[] | number | string | boolean | null

Kwd

Kwd: "maximum" | "minimum" | "exclusiveMaximum" | "exclusiveMinimum"

LimitError

LimitError: ErrorObject<"maxItems" | "minItems" | "minProperties" | "maxProperties" | "minLength" | "maxLength", { limit: number }, number | { $data: string }>

LimitNumberError

LimitNumberError: ErrorObject<Kwd, { comparison: Comparison; limit: number }, number | { $data: string }>

LocalRefs

LocalRefs: { [ Ref in string]?: AnySchemaObject }

MatchRule

MatchRule<T, R>: R extends (input: T) => infer O ? O : never

Type parameters

Multibase

Multibase<Prefix>: string | (string & { 0: Prefix })

Multibase represents base encoded strings with a prefix first character describing it's encoding.

Type parameters

  • Prefix: string

MultipleOfError

MultipleOfError: ErrorObject<"multipleOf", { multipleOf: number }, number | { $data: string }>

NotKeywordError

NotKeywordError: ErrorNoParams<"not", AnySchema>

Nullable

Nullable<T>: undefined extends T ? { const?: null; default?: T | null; enum?: Readonly<(T | null)[]>; nullable: true } : { const?: T; default?: T; enum?: Readonly<T[]> }

Type parameters

  • T

Omit

Omit<T, K>: Pick<T, Exclude<keyof T, K>>

Construct a type with the properties of T except for those in type K.

Type parameters

  • T

  • K: keyof any

OneOfError

OneOfError: ErrorObject<"oneOf", { passingSchemas: [number, number] | null }, AnySchema[]>

Partial

Partial<T>: { [ P in keyof T]?: T[P] }

Make all properties in T optional

Type parameters

  • T

Pattern

Pattern<I, O>: ((input: I) => O) | [I, O]

Format consists of multiple encoding defines what input type I maps to what output type O. It can be represented via function type or a [I, O] tuple.

Type parameters

  • I

  • O

PatternError

PatternError: ErrorObject<"pattern", { pattern: string }, string | { $data: string }>

Pick

Pick<T, K>: { [ P in K]: T[P] }

From T, pick a set of properties whose keys are in the union K

Type parameters

  • T

  • K: keyof T

PropertyDependencies

PropertyDependencies: { [ K in string]?: string[] }

PropertyNamesError

PropertyNamesError: ErrorObject<"propertyNames", { propertyName: string }, AnySchema>

ReadableStreamDefaultReadResult

ReadableStreamDefaultReadResult<T>: ReadableStreamDefaultReadValueResult<T> | ReadableStreamDefaultReadDoneResult

Type parameters

  • T

Readonly

Readonly<T>: { readonly [ P in keyof T]: T[P] }

Make all properties in T readonly

Type parameters

  • T

Record

Record<K, T>: { [ P in K]: T }

Construct a type with a set of properties K of type T

Type parameters

  • K: keyof any

  • T

RequiredError

RequiredError: ErrorObject<"required", { missingProperty: string }, string[] | { $data: string }>

Rule

Rule<Format>: Format extends [infer I, infer O] ? (input: I) => O : Format extends (input: infer I) => infer O ? (input: I) => O : never

Type parameters

Schema

Schema: SchemaObject | boolean

SchemaRefs

SchemaRefs: { [ Ref in string]?: SchemaEnv | AnySchema }

ScopeValueSets

ScopeValueSets: { [ Prefix in string]?: Set<ValueScopeName> }

StrictNullChecksWrapper

StrictNullChecksWrapper<Name, Type>: undefined extends null ? `strictNullChecks must be true in tsconfig to use ${Name}` : Type

Type parameters

  • Name: string

  • Type

Tagged

Tagged<T, Tag>: T & { tag?: Tag }

Define nominal type of U based on type of T. Similar to Opaque types in Flow

Type parameters

  • T

  • Tag

TypeError

TypeError: ErrorObject<"type", { type: string }>

TypedArray

TypedArray: Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | BigUint64Array | BigInt64Array | Float32Array | Float64Array

UncheckedJSONSchemaType

UncheckedJSONSchemaType<T, IsPartial>: ({ anyOf: readonly UncheckedJSONSchemaType<T, IsPartial>[] } | { oneOf: readonly UncheckedJSONSchemaType<T, IsPartial>[] } | ({ type: readonly (T extends number ? JSONType<"number" | "integer", IsPartial> : T extends string ? JSONType<"string", IsPartial> : T extends boolean ? JSONType<"boolean", IsPartial> : never)[] } & UnionToIntersection<T extends number ? NumberKeywords : T extends string ? StringKeywords : T extends boolean ? {} : never>) | ((T extends number ? { type: JSONType<"number" | "integer", IsPartial> } & NumberKeywords : T extends string ? { type: JSONType<"string", IsPartial> } & StringKeywords : T extends boolean ? { type: JSONType<"boolean", IsPartial> } : T extends readonly [any, ...any[]] ? { items: { readonly [ K in keyof T]-?: UncheckedJSONSchemaType<T[K], false> & Nullable<T[K]> } & { length: T["length"] }; minItems: T["length"]; type: JSONType<"array", IsPartial> } & ({ maxItems: T["length"] } | { additionalItems: false }) : T extends readonly any[] ? { additionalItems?: never; contains?: UncheckedPartialSchema<T[0]>; items: UncheckedJSONSchemaType<T[0], false>; maxContains?: number; maxItems?: number; minContains?: number; minItems?: number; type: JSONType<"array", IsPartial>; uniqueItems?: true } : T extends Record<string, any> ? { additionalProperties?: boolean | UncheckedJSONSchemaType<T[string], false>; dependencies?: { [ K in keyof T]?: Readonly<keyof T[]> | UncheckedPartialSchema<T> }; dependentRequired?: { [ K in keyof T]?: Readonly<keyof T[]> }; dependentSchemas?: { [ K in keyof T]?: UncheckedPartialSchema<T> }; maxProperties?: number; minProperties?: number; patternProperties?: Record<string, UncheckedJSONSchemaType<T[string], false>>; properties?: IsPartial extends true ? Partial<UncheckedPropertiesSchema<T>> : UncheckedPropertiesSchema<T>; propertyNames?: Omit<UncheckedJSONSchemaType<string, false>, "type"> & { type?: "string" }; type: JSONType<"object", IsPartial>; unevaluatedProperties?: boolean | UncheckedJSONSchemaType<T[string], false> } & (IsPartial extends true ? { required: Readonly<keyof T[]> } : [UncheckedRequiredMembers<T>] extends [never] ? { required?: Readonly<UncheckedRequiredMembers<T>[]> } : { required: Readonly<UncheckedRequiredMembers<T>[]> }) : T extends null ? { nullable: true; type: JSONType<"null", IsPartial> } : never) & { allOf?: Readonly<UncheckedPartialSchema<T>[]>; anyOf?: Readonly<UncheckedPartialSchema<T>[]>; else?: UncheckedPartialSchema<T>; if?: UncheckedPartialSchema<T>; not?: UncheckedPartialSchema<T>; oneOf?: Readonly<UncheckedPartialSchema<T>[]>; then?: UncheckedPartialSchema<T> })) & { $defs?: Record<string, UncheckedJSONSchemaType<Known, true>>; $id?: string; $ref?: string; definitions?: Record<string, UncheckedJSONSchemaType<Known, true>> }

Type parameters

  • T

  • IsPartial: boolean

UncheckedPartialSchema

UncheckedPartialSchema<T>: Partial<UncheckedJSONSchemaType<T, true>>

Type parameters

  • T

UncheckedPropertiesSchema

UncheckedPropertiesSchema<T>: { [ K in keyof T]-?: (UncheckedJSONSchemaType<T[K], false> & Nullable<T[K]>) | { $ref: string } }

Type parameters

  • T

UncheckedRequiredMembers

UncheckedRequiredMembers<T>: { [ K in keyof T]-?: undefined extends T[K] ? never : K }[keyof T]

Type parameters

  • T

UnevaluatedItemsError

UnevaluatedItemsError: ErrorObject<"unevaluatedItems", { limit: number }, AnySchema>

UnevaluatedPropertiesError

UnevaluatedPropertiesError: ErrorObject<"unevaluatedProperties", { unevaluatedProperty: string }, AnySchema>

UnionToIntersection

UnionToIntersection<U>: (U extends any ? (_: U) => void : never) extends (_: infer I) => void ? I : never

Type parameters

  • U

UniqueItemsError

UniqueItemsError: ErrorObject<"uniqueItems", { i: number; j: number }, boolean | { $data: string }>

UsedNames

UsedNames: Record<string, number | undefined>

ValidationKeywordError

ValidationKeywordError: LimitError | LimitNumberError | MultipleOfError | PatternError | RequiredError | UniqueItemsError | ConstError | EnumError

WithImplicitCoercion

WithImplicitCoercion<T>: T | { valueOf: any }

Type parameters

  • T

Variables

Buffer

Buffer: BufferConstructor

Error

Error: ErrorConstructor

File

File: { prototype: <internal>.File }

Type declaration

ReadableStream

ReadableStream: { prototype: <internal>.ReadableStream<any> }

Type declaration

ReadableStreamDefaultReader

ReadableStreamDefaultReader: { prototype: <internal>.ReadableStreamDefaultReader<any> }

Type declaration

SharedArrayBuffer

SharedArrayBuffer: SharedArrayBufferConstructor

WritableStream

WritableStream: { prototype: <internal>.WritableStream<any> }

Type declaration

WritableStreamDefaultWriter

WritableStreamDefaultWriter: { prototype: <internal>.WritableStreamDefaultWriter<any> }

Type declaration

Generated using TypeDoc