@atproto/lexicon 0.0.4 → 0.2.0

package/dist/lexicons.d.ts

@@ -9,8 +9,10 @@ export declare class Lexicons {
     getDef(uri: string): LexUserType | undefined;
     getDefOrThrow(uri: string, types?: string[]): LexUserType;
     validate(lexUri: string, value: unknown): ValidationResult;
-    assertValidRecord(lexUri: string, value: unknown): void;
-    assertValidXrpcParams(lexUri: string, value: unknown): void;
-    assertValidXrpcInput(lexUri: string, value: unknown): void;
-    assertValidXrpcOutput(lexUri: string, value: unknown): void;
+    assertValidRecord(lexUri: string, value: unknown): unknown;
+    assertValidXrpcParams(lexUri: string, value: unknown): unknown;
+    assertValidXrpcInput(lexUri: string, value: unknown): unknown;
+    assertValidXrpcOutput(lexUri: string, value: unknown): unknown;
+    assertValidXrpcMessage<T = unknown>(lexUri: string, value: unknown): T;
+    resolveLexUri(lexUri: string, ref: string): string;
 }

package/dist/serialize.d.ts

@@ -0,0 +1,12 @@
+import { IpldValue, JsonValue } from '@atproto/common-web';
+import { BlobRef } from './blob-refs';
+export declare type LexValue = IpldValue | BlobRef | Array<LexValue> | {
+    [key: string]: LexValue;
+};
+export declare type RepoRecord = Record<string, LexValue>;
+export declare const lexToIpld: (val: LexValue) => IpldValue;
+export declare const ipldToLex: (val: IpldValue) => LexValue;
+export declare const lexToJson: (val: LexValue) => JsonValue;
+export declare const stringifyLex: (val: LexValue) => string;
+export declare const jsonToLex: (val: JsonValue) => LexValue;
+export declare const jsonStringToLex: (val: string) => LexValue;

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './lexicons';

package/dist/src/lexicons.d.ts

@@ -0,0 +1,15 @@
+import { LexiconDoc, LexUserType } from './types';
+export declare class Lexicons {
+    docs: Map<string, LexiconDoc>;
+    defs: Map<string, LexUserType>;
+    constructor(docs?: unknown[]);
+    add(doc: unknown): void;
+    remove(uri: string): void;
+    get(uri: string): LexiconDoc | undefined;
+    getDef(uri: string): LexUserType | undefined;
+    getDefOrThrow(uri: string, types?: string[]): LexUserType;
+    assertValidRecord(lexUri: string, value: unknown): void;
+    assertValidXrpcParams(lexUri: string, value: unknown): void;
+    assertValidXrpcInput(lexUri: string, value: unknown): void;
+    assertValidXrpcOutput(lexUri: string, value: unknown): void;
+}

package/dist/src/record/index.d.ts

@@ -0,0 +1,4 @@
+export * from './schema';
+export * from './schemas';
+export * from './validator';
+export * from './validation';

package/dist/src/record/schema.d.ts

@@ -0,0 +1,9 @@
+import { ValidateFunction } from 'ajv';
+import { RecordSchema } from '../types';
+export declare class CompiledRecordSchema {
+    def: RecordSchema;
+    id: string;
+    validate?: ValidateFunction;
+    constructor(def: RecordSchema);
+}
+export default CompiledRecordSchema;

package/dist/src/record/schemas.d.ts

@@ -0,0 +1,10 @@
+import CompiledRecordSchema from './schema';
+import RecordValidator, { RecordValidatorDescription } from './validator';
+export declare class RecordSchemas {
+    schemas: Map<string, CompiledRecordSchema>;
+    add(schemaDef: unknown): void;
+    remove(key: string): void;
+    get(key: string): CompiledRecordSchema | undefined;
+    createRecordValidator(desc: string | string[] | RecordValidatorDescription): RecordValidator;
+}
+export default RecordSchemas;

package/dist/src/record/util.d.ts

@@ -0,0 +1 @@
+export declare const isRecord: (obj: unknown) => obj is Record<string, unknown>;

package/dist/src/record/validation.d.ts

@@ -0,0 +1,24 @@
+import { ValidateFunction } from 'ajv';
+import CompiledRecordSchema from './schema';
+export declare class ValidationError extends Error {
+    code: ValidationResultCode;
+    messages: string[];
+    constructor(res: ValidationResult);
+}
+export declare enum ValidationResultCode {
+    Full = "full",
+    Partial = "partial",
+    Incompatible = "incompatible",
+    Invalid = "invalid"
+}
+export declare class ValidationResult {
+    code: ValidationResultCode;
+    error: string | undefined;
+    fallbacks: string[];
+    messages: string[];
+    get valid(): boolean;
+    get fullySupported(): boolean;
+    get compatible(): boolean;
+    _t(to: ValidationResultCode, message?: string): void;
+    _fail(schema: CompiledRecordSchema, validator: ValidateFunction): void;
+}

package/dist/src/record/validator.d.ts

@@ -0,0 +1,17 @@
+import CompiledRecordSchema from './schema';
+import RecordSchemas from './schemas';
+import { ValidationResult } from './validation';
+export interface RecordValidatorDescription {
+    type: string | string[];
+    ext?: string | string[];
+}
+export declare class RecordValidator {
+    private schemas;
+    type: CompiledRecordSchema[];
+    ext: CompiledRecordSchema[];
+    constructor(schemas: RecordSchemas, type: CompiledRecordSchema[], ext: CompiledRecordSchema[]);
+    validate(value: unknown): ValidationResult;
+    isValid(value: unknown): boolean;
+    assertValid(value: unknown): ValidationResult;
+}
+export default RecordValidator;