@fern-api/venus-api-sdk 0.0.18 → 0.0.20

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fern-api/venus-api-sdk",
-    "version": "0.0.18",
+    "version": "0.0.20",
     "files": [
         "dist",
         "types",
@@ -50,7 +50,7 @@
         "@types/node": "17.0.33",
         "esbuild": "0.16.15",
         "prettier": "2.7.1",
-        "tsc-alias": "^1.7.1",
+        "tsc-alias": "1.7.1",
         "typescript": "4.6.4"
     },
     "packageManager": "yarn@3.2.4"

package/serialization.d.ts

@@ -1,3 +1,4 @@
 // this is needed for older versions of TypeScript
 // that don't read the "exports" field in package.json
 export * from "./types/serialization";
+            

package/types/api/resources/organization/client/Client.d.ts

@@ -12,13 +12,13 @@ export declare namespace Client {
 export declare class Client {
     private readonly options;
     constructor(options: Client.Options);
-    create(request: FernVenusApi.CreateOrganizationRequest): Promise<FernVenusApi.organization.create.Response>;
-    update(orgId: FernVenusApi.OrganizationId, request: FernVenusApi.UpdateOrganizationRequest): Promise<FernVenusApi.organization.update.Response>;
-    get(orgId: FernVenusApi.OrganizationId): Promise<FernVenusApi.organization.get.Response>;
-    isMember(organizationId: FernVenusApi.OrganizationId): Promise<FernVenusApi.organization.isMember.Response>;
+    create(request: FernVenusApi.CreateOrganizationRequest): Promise<core.APIResponse<void, FernVenusApi.organization.create.Error>>;
+    update(orgId: FernVenusApi.OrganizationId, request: FernVenusApi.UpdateOrganizationRequest): Promise<core.APIResponse<void, FernVenusApi.organization.update.Error>>;
+    get(orgId: FernVenusApi.OrganizationId): Promise<core.APIResponse<FernVenusApi.Organization, FernVenusApi.organization.get.Error>>;
+    isMember(organizationId: FernVenusApi.OrganizationId): Promise<core.APIResponse<boolean, FernVenusApi.organization.isMember.Error>>;
     /**
      * Returns the org for a scoped token. The token is limited to one organization.
      */
-    getMyOrganizationFromScopedToken(): Promise<FernVenusApi.organization.getMyOrganizationFromScopedToken.Response>;
-    addUser(request: FernVenusApi.AddUserToOrgRequest): Promise<FernVenusApi.organization.addUser.Response>;
+    getMyOrganizationFromScopedToken(): Promise<core.APIResponse<FernVenusApi.Organization, FernVenusApi.organization.getMyOrganizationFromScopedToken.Error>>;
+    addUser(request: FernVenusApi.AddUserToOrgRequest): Promise<core.APIResponse<void, FernVenusApi.organization.addUser.Error>>;
 }

package/types/api/resources/organization/client/addUser.d.ts

@@ -3,7 +3,6 @@
  */
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare type Response = core.APIResponse<void, FernVenusApi.organization.addUser.Error>;
 export declare type Error = FernVenusApi.organization.addUser.Error.UnauthorizedError | FernVenusApi.organization.addUser.Error.UserIdDoesNotExistError | FernVenusApi.organization.addUser.Error._Unknown;
 export declare namespace Error {
     interface UnauthorizedError extends _Utils {

package/types/api/resources/organization/client/create.d.ts

@@ -3,7 +3,6 @@
  */
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare type Response = core.APIResponse<void, FernVenusApi.organization.create.Error>;
 export declare type Error = FernVenusApi.organization.create.Error.UnauthorizedError | FernVenusApi.organization.create.Error.OrganizationAlreadyExistsError | FernVenusApi.organization.create.Error._Unknown;
 export declare namespace Error {
     interface UnauthorizedError extends _Utils {

package/types/api/resources/organization/client/get.d.ts

@@ -3,7 +3,6 @@
  */
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare type Response = core.APIResponse<FernVenusApi.Organization, FernVenusApi.organization.get.Error>;
 export declare type Error = FernVenusApi.organization.get.Error.UnauthorizedError | FernVenusApi.organization.get.Error._Unknown;
 export declare namespace Error {
     interface UnauthorizedError extends _Utils {

package/types/api/resources/organization/client/getMyOrganizationFromScopedToken.d.ts

@@ -3,7 +3,6 @@
  */
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare type Response = core.APIResponse<FernVenusApi.Organization, FernVenusApi.organization.getMyOrganizationFromScopedToken.Error>;
 export declare type Error = FernVenusApi.organization.getMyOrganizationFromScopedToken.Error.UnauthorizedError | FernVenusApi.organization.getMyOrganizationFromScopedToken.Error._Unknown;
 export declare namespace Error {
     interface UnauthorizedError extends _Utils {

package/types/api/resources/organization/client/isMember.d.ts

@@ -3,7 +3,6 @@
  */
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare type Response = core.APIResponse<boolean, FernVenusApi.organization.isMember.Error>;
 export declare type Error = FernVenusApi.organization.isMember.Error._Unknown;
 export declare namespace Error {
     interface _Unknown extends _Utils {

package/types/api/resources/organization/client/update.d.ts

@@ -3,7 +3,6 @@
  */
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare type Response = core.APIResponse<void, FernVenusApi.organization.update.Error>;
 export declare type Error = FernVenusApi.organization.update.Error.UnauthorizedError | FernVenusApi.organization.update.Error._Unknown;
 export declare namespace Error {
     interface UnauthorizedError extends _Utils {

package/types/api/resources/registry/client/Client.d.ts

@@ -12,7 +12,7 @@ export declare namespace Client {
 export declare class Client {
     private readonly options;
     constructor(options: Client.Options);
-    generateRegistryTokens(request: FernVenusApi.GenerateRegistryTokensRequest): Promise<FernVenusApi.registry.generateRegistryTokens.Response>;
-    hasRegistryPermission(request: FernVenusApi.CheckRegistryPermissionRequest): Promise<FernVenusApi.registry.hasRegistryPermission.Response>;
-    revokeToken(request: FernVenusApi.RevokeTokenRequest): Promise<FernVenusApi.registry.revokeToken.Response>;
+    generateRegistryTokens(request: FernVenusApi.GenerateRegistryTokensRequest): Promise<core.APIResponse<FernVenusApi.RegistryTokens, FernVenusApi.registry.generateRegistryTokens.Error>>;
+    hasRegistryPermission(request: FernVenusApi.CheckRegistryPermissionRequest): Promise<core.APIResponse<boolean, FernVenusApi.registry.hasRegistryPermission.Error>>;
+    revokeToken(request: FernVenusApi.RevokeTokenRequest): Promise<core.APIResponse<void, FernVenusApi.registry.revokeToken.Error>>;
 }

package/types/api/resources/registry/client/generateRegistryTokens.d.ts

@@ -3,7 +3,6 @@
  */
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare type Response = core.APIResponse<FernVenusApi.RegistryTokens, FernVenusApi.registry.generateRegistryTokens.Error>;
 export declare type Error = FernVenusApi.registry.generateRegistryTokens.Error.UnauthorizedError | FernVenusApi.registry.generateRegistryTokens.Error.OrganizationNotFoundError | FernVenusApi.registry.generateRegistryTokens.Error._Unknown;
 export declare namespace Error {
     interface UnauthorizedError extends _Utils {

package/types/api/resources/registry/client/hasRegistryPermission.d.ts

@@ -3,7 +3,6 @@
  */
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare type Response = core.APIResponse<boolean, FernVenusApi.registry.hasRegistryPermission.Error>;
 export declare type Error = FernVenusApi.registry.hasRegistryPermission.Error.UnauthorizedError | FernVenusApi.registry.hasRegistryPermission.Error.OrganizationNotFoundError | FernVenusApi.registry.hasRegistryPermission.Error._Unknown;
 export declare namespace Error {
     interface UnauthorizedError extends _Utils {

package/types/api/resources/registry/client/revokeToken.d.ts

@@ -3,7 +3,6 @@
  */
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare type Response = core.APIResponse<void, FernVenusApi.registry.revokeToken.Error>;
 export declare type Error = FernVenusApi.registry.revokeToken.Error.UnauthorizedError | FernVenusApi.registry.revokeToken.Error.OrganizationNotFoundError | FernVenusApi.registry.revokeToken.Error._Unknown;
 export declare namespace Error {
     interface UnauthorizedError extends _Utils {

package/types/api/resources/user/client/Client.d.ts

@@ -12,6 +12,6 @@ export declare namespace Client {
 export declare class Client {
     private readonly options;
     constructor(options: Client.Options);
-    getMyself(): Promise<FernVenusApi.user.getMyself.Response>;
-    getMyOrganizations(request: FernVenusApi.GetUserOrganizationsRequest): Promise<FernVenusApi.user.getMyOrganizations.Response>;
+    getMyself(): Promise<core.APIResponse<FernVenusApi.User, FernVenusApi.user.getMyself.Error>>;
+    getMyOrganizations(request: FernVenusApi.GetUserOrganizationsRequest): Promise<core.APIResponse<FernVenusApi.OrganizationsPage, FernVenusApi.user.getMyOrganizations.Error>>;
 }

package/types/api/resources/user/client/getMyOrganizations.d.ts

@@ -3,7 +3,6 @@
  */
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare type Response = core.APIResponse<FernVenusApi.OrganizationsPage, FernVenusApi.user.getMyOrganizations.Error>;
 export declare type Error = FernVenusApi.user.getMyOrganizations.Error._Unknown;
 export declare namespace Error {
     interface _Unknown extends _Utils {

package/types/api/resources/user/client/getMyself.d.ts

@@ -3,7 +3,6 @@
  */
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare type Response = core.APIResponse<FernVenusApi.User, FernVenusApi.user.getMyself.Error>;
 export declare type Error = FernVenusApi.user.getMyself.Error._Unknown;
 export declare namespace Error {
     interface _Unknown extends _Utils {

package/types/core/fetcher/Fetcher.d.ts

@@ -11,12 +11,12 @@ export declare namespace Fetcher {
         queryParameters?: URLSearchParams;
         body?: unknown;
         timeoutMs?: number;
+        withCredentials?: boolean;
     }
     type Error = FailedStatusCodeError | NonJsonError | TimeoutError | UnknownError;
     interface FailedStatusCodeError {
         reason: "status-code";
         statusCode: number;
-        rawBody: string | undefined;
         body: unknown;
     }
     interface NonJsonError {

package/types/core/schemas/Schema.d.ts

@@ -1,18 +1,46 @@
 import { SchemaUtils } from "./builders";
+import { MaybePromise } from "./utils/MaybePromise";
 export declare type Schema<Raw = unknown, Parsed = unknown> = BaseSchema<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export declare type inferRaw<S extends Schema> = S extends Schema<infer Raw, any> ? Raw : never;
 export declare type inferParsed<S extends Schema> = S extends Schema<any, infer Parsed> ? Parsed : never;
 export interface BaseSchema<Raw, Parsed> {
-    parse: (raw: Raw, opts?: SchemaOptions) => Parsed | Promise<Parsed>;
-    json: (parsed: Parsed, opts?: SchemaOptions) => Raw | Promise<Raw>;
+    parse: (raw: unknown, opts?: SchemaOptions) => MaybePromise<MaybeValid<Parsed>>;
+    json: (parsed: unknown, opts?: SchemaOptions) => MaybePromise<MaybeValid<Raw>>;
+    getType: () => SchemaType | Promise<SchemaType>;
+}
+export declare const SchemaType: {
+    readonly DATE: "date";
+    readonly ENUM: "enum";
+    readonly LIST: "list";
+    readonly STRING_LITERAL: "stringLiteral";
+    readonly OBJECT: "object";
+    readonly ANY: "any";
+    readonly BOOLEAN: "boolean";
+    readonly NUMBER: "number";
+    readonly STRING: "string";
+    readonly UNKNOWN: "unknown";
+    readonly RECORD: "record";
+    readonly SET: "set";
+    readonly UNION: "union";
+    readonly OPTIONAL: "optional";
+};
+export declare type SchemaType = typeof SchemaType[keyof typeof SchemaType];
+export declare type MaybeValid<T> = Valid<T> | Invalid;
+export interface Valid<T> {
+    ok: true;
+    value: T;
+}
+export interface Invalid {
+    ok: false;
+    errors: ValidationError[];
+}
+export interface ValidationError {
+    path: string[];
+    message: string;
 }
 export interface SchemaOptions {
     /**
      * @default false
      */
-    skipUnknownKeysOnParse?: boolean;
-    /**
-     * @default false
-     */
-    includeUnknownKeysOnJson?: boolean;
+    allowUnknownKeys?: boolean;
 }

package/types/core/schemas/builders/enum/enum.d.ts

@@ -1,2 +1,2 @@
 import { Schema } from "../../Schema";
-export declare function enum_<U extends string, E extends Readonly<[U, ...U[]]>>(_values: E): Schema<E[number], E[number]>;
+export declare function enum_<U extends string, E extends U[]>(values: E): Schema<E[number], E[number]>;

package/types/core/schemas/builders/index.d.ts

@@ -1,6 +1,5 @@
 export * from "./date";
 export * from "./enum";
-export * from "./identity";
 export * from "./lazy";
 export * from "./list";
 export * from "./literals";

package/types/core/schemas/builders/literals/stringLiteral.d.ts

@@ -1,2 +1,2 @@
 import { Schema } from "../../Schema";
-export declare function stringLiteral<V extends string>(_value: V): Schema<V, V>;
+export declare function stringLiteral<V extends string>(literal: V): Schema<V, V>;

package/types/core/schemas/builders/object/types.d.ts

@@ -1,9 +1,10 @@
-import { inferParsed, inferRaw, Schema } from "../../Schema";
+import { BaseSchema, inferParsed, inferRaw, Schema } from "../../Schema";
 import { addQuestionMarksToNullableProperties } from "../../utils/addQuestionMarksToNullableProperties";
-import { BaseObjectLikeSchema, ObjectLikeSchema } from "../object-like";
+import { ObjectLikeUtils } from "../object-like";
+import { SchemaUtils } from "../schema-utils";
 import { Property } from "./property";
-export declare type ObjectSchema<Raw, Parsed> = BaseObjectSchema<Raw, Parsed> & ObjectLikeSchema<Raw, Parsed> & ObjectUtils<Raw, Parsed>;
-export interface BaseObjectSchema<Raw, Parsed> extends BaseObjectLikeSchema<Raw, Parsed> {
+export declare type ObjectSchema<Raw, Parsed> = BaseObjectSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed> & ObjectUtils<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
+export interface BaseObjectSchema<Raw, Parsed> extends BaseSchema<Raw, Parsed> {
     _getRawProperties: () => Promise<(keyof Raw)[]>;
     _getParsedProperties: () => Promise<(keyof Parsed)[]>;
 }

package/types/core/schemas/builders/object-like/getObjectLikeUtils.d.ts

@@ -1,8 +1,9 @@
-import { BaseObjectLikeSchema, ObjectLikeSchema, ObjectLikeUtils } from "./types";
-export declare function getObjectLikeUtils<Raw, Parsed>(schema: BaseObjectLikeSchema<Raw, Parsed>): ObjectLikeUtils<Raw, Parsed>;
+import { BaseSchema } from "../../Schema";
+import { ObjectLikeSchema, ObjectLikeUtils } from "./types";
+export declare function getObjectLikeUtils<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): ObjectLikeUtils<Raw, Parsed>;
 /**
  * object-like utils are defined in one file to resolve issues with circular imports
  */
-export declare function withProperties<RawObjectShape, ParsedObjectShape, Properties>(objectLike: BaseObjectLikeSchema<RawObjectShape, ParsedObjectShape>, properties: {
+export declare function withParsedProperties<RawObjectShape, ParsedObjectShape, Properties>(objectLike: BaseSchema<RawObjectShape, ParsedObjectShape>, properties: {
     [K in keyof Properties]: Properties[K] | ((parsed: ParsedObjectShape) => Properties[K]);
 }): ObjectLikeSchema<RawObjectShape, ParsedObjectShape & Properties>;

package/types/core/schemas/builders/object-like/index.d.ts

@@ -1,2 +1,2 @@
-export { getObjectLikeUtils, withProperties } from "./getObjectLikeUtils";
-export { OBJECT_LIKE_BRAND, type BaseObjectLikeSchema, type ObjectLikeSchema, type ObjectLikeUtils } from "./types";
+export { getObjectLikeUtils, withParsedProperties } from "./getObjectLikeUtils";
+export { type ObjectLikeSchema, type ObjectLikeUtils } from "./types";

package/types/core/schemas/builders/object-like/types.d.ts

@@ -1,13 +1,7 @@
 import { BaseSchema, Schema } from "../../Schema";
-export declare type ObjectLikeSchema<Raw, Parsed> = Schema<Raw, Parsed> & BaseObjectLikeSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed>;
-export declare type BaseObjectLikeSchema<Raw, Parsed> = BaseSchema<Raw, Parsed> & {
-    _objectLike: void;
-};
+export declare type ObjectLikeSchema<Raw, Parsed> = Schema<Raw, Parsed> & BaseSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed>;
 export interface ObjectLikeUtils<Raw, Parsed> {
-    withProperties: <T extends Record<string, any>>(properties: {
+    withParsedProperties: <T extends Record<string, any>>(properties: {
         [K in keyof T]: T[K] | ((parsed: Parsed) => T[K]);
     }) => ObjectLikeSchema<Raw, Parsed & T>;
 }
-export declare const OBJECT_LIKE_BRAND: {
-    _objectLike: void;
-};

package/types/core/schemas/builders/primitives/any.d.ts

@@ -1 +1 @@
-export declare const any: () => import("../..").Schema<any, any>;
+export declare const any: () => import("../../Schema").Schema<any, any>;

package/types/core/schemas/builders/primitives/boolean.d.ts

@@ -1 +1 @@
-export declare const boolean: () => import("../..").Schema<boolean, boolean>;
+export declare const boolean: () => import("../../Schema").Schema<boolean, boolean>;

package/types/core/schemas/builders/primitives/number.d.ts

@@ -1 +1 @@
-export declare const number: () => import("../..").Schema<number, number>;
+export declare const number: () => import("../../Schema").Schema<number, number>;

package/types/core/schemas/builders/primitives/string.d.ts

@@ -1 +1 @@
-export declare const string: () => import("../..").Schema<string, string>;
+export declare const string: () => import("../../Schema").Schema<string, string>;

package/types/core/schemas/builders/primitives/unknown.d.ts

@@ -1 +1 @@
-export declare const unknown: () => import("../..").Schema<unknown, unknown>;
+export declare const unknown: () => import("../../Schema").Schema<unknown, unknown>;

package/types/core/schemas/builders/record/index.d.ts

@@ -1 +1,2 @@
 export { record } from "./record";
+export { type BaseRecordSchema, type RecordSchema } from "./types";

package/types/core/schemas/builders/record/record.d.ts

@@ -1,2 +1,3 @@
 import { Schema } from "../../Schema";
-export declare function record<RawKey extends string | number, ParsedKey extends string | number, RawValue, ParsedValue>(keySchema: Schema<RawKey, ParsedKey>, valueSchema: Schema<RawValue, ParsedValue>): Schema<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
+import { RecordSchema } from "./types";
+export declare function record<RawKey extends string | number, RawValue, ParsedValue, ParsedKey extends string | number>(keySchema: Schema<RawKey, ParsedKey>, valueSchema: Schema<RawValue, ParsedValue>): RecordSchema<RawKey, RawValue, ParsedKey, ParsedValue>;

package/types/core/schemas/builders/record/types.d.ts

@@ -0,0 +1,5 @@
+import { BaseSchema } from "../../Schema";
+import { OptionalRecord } from "../../utils/OptionalRecord";
+import { SchemaUtils } from "../schema-utils";
+export declare type RecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseRecordSchema<RawKey, RawValue, ParsedKey, ParsedValue> & SchemaUtils<OptionalRecord<RawKey, RawValue>, OptionalRecord<ParsedKey, ParsedValue>>;
+export declare type BaseRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseSchema<OptionalRecord<RawKey, RawValue>, OptionalRecord<ParsedKey, ParsedValue>>;

package/types/core/schemas/builders/schema-utils/JsonError.d.ts

@@ -0,0 +1,5 @@
+import { ValidationError } from "../../Schema";
+export declare class JsonError extends Error {
+    readonly errors: ValidationError[];
+    constructor(errors: ValidationError[]);
+}

package/types/core/schemas/builders/schema-utils/ParseError.d.ts

@@ -0,0 +1,5 @@
+import { ValidationError } from "../../Schema";
+export declare class ParseError extends Error {
+    readonly errors: ValidationError[];
+    constructor(errors: ValidationError[]);
+}

package/types/core/schemas/builders/schema-utils/getSchemaUtils.d.ts

@@ -1,12 +1,17 @@
-import { BaseSchema, Schema } from "../../Schema";
-import { OptionalSchema } from "./types";
+import { BaseSchema, Schema, SchemaOptions } from "../../Schema";
 export interface SchemaUtils<Raw, Parsed> {
-    optional: () => OptionalSchema<Raw, Parsed>;
-    transform: <PostTransform>(transformer: BaseSchema<Parsed, PostTransform>) => Schema<Raw, PostTransform>;
+    optional: () => Schema<Raw | null | undefined, Parsed | undefined>;
+    transform: <Transformed>(transformer: SchemaTransformer<Parsed, Transformed>) => Schema<Raw, Transformed>;
+    parseOrThrow: (raw: unknown, opts?: SchemaOptions) => Promise<Parsed>;
+    jsonOrThrow: (raw: unknown, opts?: SchemaOptions) => Promise<Raw>;
+}
+export interface SchemaTransformer<Parsed, Transformed> {
+    transform: (parsed: Parsed) => Transformed;
+    untransform: (transformed: any) => Parsed;
 }
 export declare function getSchemaUtils<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): SchemaUtils<Raw, Parsed>;
 /**
  * schema utils are defined in one file to resolve issues with circular imports
  */
-export declare function optional<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): OptionalSchema<Raw, Parsed>;
-export declare function transform<PreTransformRaw, PreTransformParsed, PostTransform>(schema: BaseSchema<PreTransformRaw, PreTransformParsed>, transformer: BaseSchema<PreTransformParsed, PostTransform>): Schema<PreTransformRaw, PostTransform>;
+export declare function optional<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null | undefined, Parsed | undefined>;
+export declare function transform<Raw, Parsed, Transformed>(schema: BaseSchema<Raw, Parsed>, transformer: SchemaTransformer<Parsed, Transformed>): Schema<Raw, Transformed>;

package/types/core/schemas/builders/schema-utils/index.d.ts

@@ -1,2 +1,3 @@
 export { getSchemaUtils, optional, transform, type SchemaUtils } from "./getSchemaUtils";
-export { OPTIONAL_BRAND, type OptionalSchema } from "./types";
+export { JsonError } from "./JsonError";
+export { ParseError } from "./ParseError";

package/types/core/schemas/builders/schema-utils/stringifyValidationErrors.d.ts

@@ -0,0 +1,2 @@
+import { ValidationError } from "../../Schema";
+export declare function stringifyValidationError(error: ValidationError): string;

package/types/core/schemas/utils/MaybePromise.d.ts

@@ -0,0 +1 @@
+export declare type MaybePromise<T> = T | Promise<T>;

package/types/core/schemas/utils/OptionalRecord.d.ts

@@ -0,0 +1 @@
+export declare type OptionalRecord<K extends string | number, V> = Record<K, V | undefined>;

package/types/core/schemas/utils/addQuestionMarksToNullableProperties.d.ts

@@ -1,9 +1,9 @@
 export declare type addQuestionMarksToNullableProperties<T> = {
-    [K in OptionalKeys<T>]?: undefined extends T[K] ? T[K] : never;
+    [K in OptionalKeys<T>]?: T[K];
 } & Pick<T, RequiredKeys<T>>;
 export declare type OptionalKeys<T> = {
-    [K in keyof T]: undefined extends T[K] ? K : never;
+    [K in keyof T]: undefined extends T[K] ? K : null extends T[K] ? K : never;
 }[keyof T];
 export declare type RequiredKeys<T> = {
-    [K in keyof T]: undefined extends T[K] ? never : K;
+    [K in keyof T]: undefined extends T[K] ? never : null extends T[K] ? never : K;
 }[keyof T];

package/types/core/schemas/utils/createIdentitySchemaCreator.d.ts

@@ -0,0 +1,2 @@
+import { MaybeValid, Schema, SchemaOptions, SchemaType } from "../Schema";
+export declare function createIdentitySchemaCreator<T>(schemaType: SchemaType, validate: (value: unknown, opts?: SchemaOptions) => MaybeValid<T>): () => Schema<T, T>;

package/types/core/schemas/utils/isPlainObject.d.ts

@@ -0,0 +1,2 @@
+export declare const NOT_AN_OBJECT_ERROR_MESSAGE = "Not an object";
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;

package/types/serialization/resources/index.d.ts

@@ -6,3 +6,5 @@ export * as registry from "./registry";
 export * from "./registry/types";
 export * as user from "./user";
 export * from "./user/types";
+export * from "./organization/client/requests";
+export * from "./registry/client/requests";

package/types/serialization/resources/organization/client/addUser.d.ts

@@ -4,13 +4,6 @@
 import * as serializers from "../../..";
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare const Request: core.serialization.Schema<serializers.organization.addUser.Request.Raw, FernVenusApi.AddUserToOrgRequest>;
-export declare namespace Request {
-    interface Raw {
-        userId: serializers.UserId.Raw;
-        orgId: serializers.OrganizationId.Raw;
-    }
-}
 export declare const Error: core.serialization.Schema<serializers.organization.addUser.Error.Raw, FernVenusApi.organization.addUser.Error>;
 export declare namespace Error {
     type Raw = Error.UnauthorizedError | Error.UserIdDoesNotExistError;

package/types/serialization/resources/organization/client/create.d.ts

@@ -4,13 +4,6 @@
 import * as serializers from "../../..";
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare const Request: core.serialization.Schema<serializers.organization.create.Request.Raw, FernVenusApi.CreateOrganizationRequest>;
-export declare namespace Request {
-    interface Raw {
-        organizationId: serializers.OrganizationId.Raw;
-        artifactReadRequiresToken?: boolean | null;
-    }
-}
 export declare const Error: core.serialization.Schema<serializers.organization.create.Error.Raw, FernVenusApi.organization.create.Error>;
 export declare namespace Error {
     type Raw = Error.UnauthorizedError | Error.OrganizationAlreadyExistsError;

package/types/serialization/resources/organization/client/get.d.ts

@@ -4,10 +4,6 @@
 import * as serializers from "../../..";
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare const Response: core.serialization.Schema<serializers.organization.get.Response.Raw, FernVenusApi.Organization>;
-export declare namespace Response {
-    type Raw = serializers.Organization.Raw;
-}
 export declare const Error: core.serialization.Schema<serializers.organization.get.Error.Raw, FernVenusApi.organization.get.Error>;
 export declare namespace Error {
     type Raw = Error.UnauthorizedError;

package/types/serialization/resources/organization/client/getMyOrganizationFromScopedToken.d.ts

@@ -4,10 +4,6 @@
 import * as serializers from "../../..";
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare const Response: core.serialization.Schema<serializers.organization.getMyOrganizationFromScopedToken.Response.Raw, FernVenusApi.Organization>;
-export declare namespace Response {
-    type Raw = serializers.Organization.Raw;
-}
 export declare const Error: core.serialization.Schema<serializers.organization.getMyOrganizationFromScopedToken.Error.Raw, FernVenusApi.organization.getMyOrganizationFromScopedToken.Error>;
 export declare namespace Error {
     type Raw = Error.UnauthorizedError;

package/types/serialization/resources/organization/client/index.d.ts

@@ -4,3 +4,4 @@ export * as get from "./get";
 export * as isMember from "./isMember";
 export * as getMyOrganizationFromScopedToken from "./getMyOrganizationFromScopedToken";
 export * as addUser from "./addUser";
+export * from "./requests";

package/types/serialization/resources/organization/client/requests/AddUserToOrgRequest.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../../../..";
+import { FernVenusApi } from "../../../../..";
+import * as core from "../../../../../core";
+export declare const AddUserToOrgRequest: core.serialization.Schema<serializers.AddUserToOrgRequest.Raw, FernVenusApi.AddUserToOrgRequest>;
+export declare namespace AddUserToOrgRequest {
+    interface Raw {
+        userId: serializers.UserId.Raw;
+        orgId: serializers.OrganizationId.Raw;
+    }
+}

package/types/serialization/resources/organization/client/requests/CreateOrganizationRequest.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../../../..";
+import { FernVenusApi } from "../../../../..";
+import * as core from "../../../../../core";
+export declare const CreateOrganizationRequest: core.serialization.Schema<serializers.CreateOrganizationRequest.Raw, FernVenusApi.CreateOrganizationRequest>;
+export declare namespace CreateOrganizationRequest {
+    interface Raw {
+        organizationId: serializers.OrganizationId.Raw;
+        artifactReadRequiresToken?: boolean | null;
+    }
+}

package/types/serialization/resources/organization/client/requests/UpdateOrganizationRequest.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../../../..";
+import { FernVenusApi } from "../../../../..";
+import * as core from "../../../../../core";
+export declare const UpdateOrganizationRequest: core.serialization.Schema<serializers.UpdateOrganizationRequest.Raw, FernVenusApi.UpdateOrganizationRequest>;
+export declare namespace UpdateOrganizationRequest {
+    interface Raw {
+        artifactReadRequiresToken: boolean;
+    }
+}

package/types/serialization/resources/organization/client/requests/index.d.ts

@@ -0,0 +1,3 @@
+export { CreateOrganizationRequest } from "./CreateOrganizationRequest";
+export { UpdateOrganizationRequest } from "./UpdateOrganizationRequest";
+export { AddUserToOrgRequest } from "./AddUserToOrgRequest";

package/types/serialization/resources/organization/client/update.d.ts

@@ -4,12 +4,6 @@
 import * as serializers from "../../..";
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare const Request: core.serialization.Schema<serializers.organization.update.Request.Raw, FernVenusApi.UpdateOrganizationRequest>;
-export declare namespace Request {
-    interface Raw {
-        artifactReadRequiresToken: boolean;
-    }
-}
 export declare const Error: core.serialization.Schema<serializers.organization.update.Error.Raw, FernVenusApi.organization.update.Error>;
 export declare namespace Error {
     type Raw = Error.UnauthorizedError;

package/types/serialization/resources/registry/client/generateRegistryTokens.d.ts

@@ -4,16 +4,6 @@
 import * as serializers from "../../..";
 import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare const Request: core.serialization.Schema<serializers.registry.generateRegistryTokens.Request.Raw, FernVenusApi.GenerateRegistryTokensRequest>;
-export declare namespace Request {
-    interface Raw {
-        organizationId: serializers.OrganizationId.Raw;
-    }
-}
-export declare const Response: core.serialization.Schema<serializers.registry.generateRegistryTokens.Response.Raw, FernVenusApi.RegistryTokens>;
-export declare namespace Response {
-    type Raw = serializers.RegistryTokens.Raw;
-}
 export declare const Error: core.serialization.Schema<serializers.registry.generateRegistryTokens.Error.Raw, FernVenusApi.registry.generateRegistryTokens.Error>;
 export declare namespace Error {
     type Raw = Error.UnauthorizedError | Error.OrganizationNotFoundError;

package/types/serialization/resources/registry/client/hasRegistryPermission.d.ts

@@ -2,15 +2,8 @@
  * This file was auto-generated by Fern from our API Definition.
  */
 import * as serializers from "../../..";
-import { FernVenusApi } from "../../../..";
 import * as core from "../../../../core";
-export declare const Request: core.serialization.Schema<serializers.registry.hasRegistryPermission.Request.Raw, FernVenusApi.CheckRegistryPermissionRequest>;
-export declare namespace Request {
-    interface Raw {
-        organizationId: serializers.OrganizationId.Raw;
-        token?: serializers.RegistryToken.Raw | null;
-    }
-}
+import { FernVenusApi } from "../../../..";
 export declare const Response: core.serialization.Schema<serializers.registry.hasRegistryPermission.Response.Raw, boolean>;
 export declare namespace Response {
     type Raw = boolean;

package/types/serialization/resources/registry/client/index.d.ts

@@ -1,3 +1,4 @@
 export * as generateRegistryTokens from "./generateRegistryTokens";
 export * as hasRegistryPermission from "./hasRegistryPermission";
 export * as revokeToken from "./revokeToken";
+export * from "./requests";