@mastra/schema-compat 1.3.11-alpha.0 → 1.3.11-alpha.1

package/dist/_types/ajv/dist/vocabularies/applicator/anyOf.d.ts

@@ -0,0 +1,4 @@
+import type { CodeKeywordDefinition, ErrorNoParams, AnySchema } from "../../types";
+export type AnyOfError = ErrorNoParams<"anyOf", AnySchema[]>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/applicator/contains.d.ts

@@ -0,0 +1,7 @@
+import type { CodeKeywordDefinition, ErrorObject, AnySchema } from "../../types";
+export type ContainsError = ErrorObject<"contains", {
+    minContains: number;
+    maxContains?: number;
+}, AnySchema>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/applicator/dependencies.d.ts

@@ -0,0 +1,21 @@
+import type { CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition, SchemaMap, AnySchema } from "../../types";
+import type { KeywordCxt } from "../../compile/validate";
+export type PropertyDependencies = {
+    [K in string]?: string[];
+};
+export interface DependenciesErrorParams {
+    property: string;
+    missingProperty: string;
+    depsCount: number;
+    deps: string;
+}
+export type DependenciesError = ErrorObject<"dependencies", DependenciesErrorParams, {
+    [K in string]?: string[] | AnySchema;
+}>;
+export declare const error: KeywordErrorDefinition;
+declare const def: CodeKeywordDefinition;
+export declare function validatePropertyDeps(cxt: KeywordCxt, propertyDeps?: {
+    [K in string]?: string[];
+}): void;
+export declare function validateSchemaDeps(cxt: KeywordCxt, schemaDeps?: SchemaMap): void;
+export default def;

package/dist/_types/ajv/dist/vocabularies/applicator/if.d.ts

@@ -0,0 +1,6 @@
+import type { CodeKeywordDefinition, ErrorObject, AnySchema } from "../../types";
+export type IfKeywordError = ErrorObject<"if", {
+    failingKeyword: string;
+}, AnySchema>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/applicator/index.d.ts

@@ -0,0 +1,13 @@
+import type { ErrorNoParams, Vocabulary } from "../../types";
+import { AdditionalItemsError } from "./additionalItems";
+import { ItemsError } from "./items2020";
+import { ContainsError } from "./contains";
+import { DependenciesError } from "./dependencies";
+import { PropertyNamesError } from "./propertyNames";
+import { AdditionalPropertiesError } from "./additionalProperties";
+import { NotKeywordError } from "./not";
+import { AnyOfError } from "./anyOf";
+import { OneOfError } from "./oneOf";
+import { IfKeywordError } from "./if";
+export default function getApplicator(draft2020?: boolean): Vocabulary;
+export type ApplicatorKeywordError = ErrorNoParams<"false schema"> | AdditionalItemsError | ItemsError | ContainsError | AdditionalPropertiesError | DependenciesError | IfKeywordError | AnyOfError | OneOfError | NotKeywordError | PropertyNamesError;

package/dist/_types/ajv/dist/vocabularies/applicator/items2020.d.ts

@@ -0,0 +1,6 @@
+import type { CodeKeywordDefinition, ErrorObject, AnySchema } from "../../types";
+export type ItemsError = ErrorObject<"items", {
+    limit: number;
+}, AnySchema>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/applicator/not.d.ts

@@ -0,0 +1,4 @@
+import type { CodeKeywordDefinition, ErrorNoParams, AnySchema } from "../../types";
+export type NotKeywordError = ErrorNoParams<"not", AnySchema>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/applicator/oneOf.d.ts

@@ -0,0 +1,6 @@
+import type { CodeKeywordDefinition, ErrorObject, AnySchema } from "../../types";
+export type OneOfError = ErrorObject<"oneOf", {
+    passingSchemas: [number, number] | null;
+}, AnySchema[]>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/applicator/propertyNames.d.ts

@@ -0,0 +1,6 @@
+import type { CodeKeywordDefinition, ErrorObject, AnySchema } from "../../types";
+export type PropertyNamesError = ErrorObject<"propertyNames", {
+    propertyName: string;
+}, AnySchema>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/discriminator/index.d.ts

@@ -0,0 +1,5 @@
+import type { CodeKeywordDefinition } from "../../types";
+import { DiscrError, DiscrErrorObj } from "../discriminator/types";
+export type DiscriminatorError = DiscrErrorObj<DiscrError.Tag> | DiscrErrorObj<DiscrError.Mapping>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/discriminator/types.d.ts

@@ -0,0 +1,10 @@
+import type { ErrorObject } from "../../types";
+export declare enum DiscrError {
+    Tag = "tag",
+    Mapping = "mapping"
+}
+export type DiscrErrorObj<E extends DiscrError> = ErrorObject<"discriminator", {
+    error: E;
+    tag: string;
+    tagValue: unknown;
+}, string>;

package/dist/_types/ajv/dist/vocabularies/errors.d.ts

@@ -0,0 +1,9 @@
+import type { TypeError } from "../compile/validate/dataType";
+import type { ApplicatorKeywordError } from "./applicator";
+import type { ValidationKeywordError } from "./validation";
+import type { FormatError } from "./format/format";
+import type { UnevaluatedPropertiesError } from "./unevaluated/unevaluatedProperties";
+import type { UnevaluatedItemsError } from "./unevaluated/unevaluatedItems";
+import type { DependentRequiredError } from "./validation/dependentRequired";
+import type { DiscriminatorError } from "./discriminator";
+export type DefinedError = TypeError | ApplicatorKeywordError | ValidationKeywordError | FormatError | UnevaluatedPropertiesError | UnevaluatedItemsError | DependentRequiredError | DiscriminatorError;

package/dist/_types/ajv/dist/vocabularies/format/format.d.ts

@@ -0,0 +1,8 @@
+import type { CodeKeywordDefinition, ErrorObject } from "../../types";
+export type FormatError = ErrorObject<"format", {
+    format: string;
+}, string | {
+    $data: string;
+}>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/unevaluated/unevaluatedItems.d.ts

@@ -0,0 +1,6 @@
+import type { CodeKeywordDefinition, ErrorObject, AnySchema } from "../../types";
+export type UnevaluatedItemsError = ErrorObject<"unevaluatedItems", {
+    limit: number;
+}, AnySchema>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.d.ts

@@ -0,0 +1,6 @@
+import type { CodeKeywordDefinition, ErrorObject, AnySchema } from "../../types";
+export type UnevaluatedPropertiesError = ErrorObject<"unevaluatedProperties", {
+    unevaluatedProperty: string;
+}, AnySchema>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/validation/const.d.ts

@@ -0,0 +1,6 @@
+import type { CodeKeywordDefinition, ErrorObject } from "../../types";
+export type ConstError = ErrorObject<"const", {
+    allowedValue: any;
+}>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/validation/dependentRequired.d.ts

@@ -0,0 +1,5 @@
+import type { CodeKeywordDefinition, ErrorObject } from "../../types";
+import { DependenciesErrorParams, PropertyDependencies } from "../applicator/dependencies";
+export type DependentRequiredError = ErrorObject<"dependentRequired", DependenciesErrorParams, PropertyDependencies>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/validation/enum.d.ts

@@ -0,0 +1,8 @@
+import type { CodeKeywordDefinition, ErrorObject } from "../../types";
+export type EnumError = ErrorObject<"enum", {
+    allowedValues: any[];
+}, any[] | {
+    $data: string;
+}>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/validation/index.d.ts

@@ -0,0 +1,16 @@
+import type { ErrorObject, Vocabulary } from "../../types";
+import { LimitNumberError } from "./limitNumber";
+import { MultipleOfError } from "./multipleOf";
+import { PatternError } from "./pattern";
+import { RequiredError } from "./required";
+import { UniqueItemsError } from "./uniqueItems";
+import { ConstError } from "./const";
+import { EnumError } from "./enum";
+declare const validation: Vocabulary;
+export default validation;
+type LimitError = ErrorObject<"maxItems" | "minItems" | "minProperties" | "maxProperties" | "minLength" | "maxLength", {
+    limit: number;
+}, number | {
+    $data: string;
+}>;
+export type ValidationKeywordError = LimitError | LimitNumberError | MultipleOfError | PatternError | RequiredError | UniqueItemsError | ConstError | EnumError;

package/dist/_types/ajv/dist/vocabularies/validation/limitNumber.d.ts

@@ -0,0 +1,11 @@
+import type { CodeKeywordDefinition, ErrorObject } from "../../types";
+type Kwd = "maximum" | "minimum" | "exclusiveMaximum" | "exclusiveMinimum";
+type Comparison = "<=" | ">=" | "<" | ">";
+export type LimitNumberError = ErrorObject<Kwd, {
+    limit: number;
+    comparison: Comparison;
+}, number | {
+    $data: string;
+}>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/validation/multipleOf.d.ts

@@ -0,0 +1,8 @@
+import type { CodeKeywordDefinition, ErrorObject } from "../../types";
+export type MultipleOfError = ErrorObject<"multipleOf", {
+    multipleOf: number;
+}, number | {
+    $data: string;
+}>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/validation/pattern.d.ts

@@ -0,0 +1,8 @@
+import type { CodeKeywordDefinition, ErrorObject } from "../../types";
+export type PatternError = ErrorObject<"pattern", {
+    pattern: string;
+}, string | {
+    $data: string;
+}>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/validation/required.d.ts

@@ -0,0 +1,8 @@
+import type { CodeKeywordDefinition, ErrorObject } from "../../types";
+export type RequiredError = ErrorObject<"required", {
+    missingProperty: string;
+}, string[] | {
+    $data: string;
+}>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/dist/vocabularies/validation/uniqueItems.d.ts

@@ -0,0 +1,9 @@
+import type { CodeKeywordDefinition, ErrorObject } from "../../types";
+export type UniqueItemsError = ErrorObject<"uniqueItems", {
+    i: number;
+    j: number;
+}, boolean | {
+    $data: string;
+}>;
+declare const def: CodeKeywordDefinition;
+export default def;

package/dist/_types/ajv/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/_types/fast-uri/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/_types/fast-uri/types/index.d.ts

@@ -0,0 +1,60 @@
+type FastUri = typeof fastUri
+
+declare namespace fastUri {
+  export interface URIComponent {
+    scheme?: string;
+    userinfo?: string;
+    host?: string;
+    port?: number | string;
+    path?: string;
+    query?: string;
+    fragment?: string;
+    reference?: string;
+    nid?: string;
+    nss?: string;
+    resourceName?: string;
+    secure?: boolean;
+    uuid?: string;
+    error?: string;
+  }
+  export interface Options {
+    scheme?: string;
+    reference?: string;
+    unicodeSupport?: boolean;
+    domainHost?: boolean;
+    absolutePath?: boolean;
+    tolerant?: boolean;
+    skipEscape?: boolean;
+    nid?: string;
+  }
+
+  /**
+   * @deprecated Use Options instead
+   */
+  export type options = Options
+  /**
+   * @deprecated Use URIComponent instead
+   */
+  export type URIComponents = URIComponent
+
+  export function normalize (uri: string, opts?: Options): string
+  export function normalize (uri: URIComponent, opts?: Options): URIComponent
+  export function normalize (uri: any, opts?: Options): any
+
+  export function resolve (baseURI: string, relativeURI: string, options?: Options): string
+
+  export function resolveComponent (base: URIComponent, relative: URIComponent, options?: Options, skipNormalization?: boolean): URIComponent
+
+  export function parse (uri: string, opts?: Options): URIComponent
+
+  export function serialize (component: URIComponent, opts?: Options): string
+
+  export function equal (uriA: string, uriB: string): boolean
+
+  export function resolve (base: string, path: string): string
+
+  export const fastUri: FastUri
+  export { fastUri as default }
+}
+
+export = fastUri

package/dist/index.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_json_schema_traverse$1 = require("./json-schema-traverse-DbuWNYgg.cjs");
 const require_zod_to_json = require("./zod-to-json.cjs");
-const require_schema = require("./schema-5p36X0wR.cjs");
+const require_schema = require("./schema-D35TsNfD.cjs");
 let zod_v3 = require("zod/v3");
 let zod = require("zod");
 let zod_from_json_schema = require("zod-from-json-schema");
@@ -6058,6 +6058,7 @@ var GoogleSchemaCompatLayer = class extends SchemaCompatLayer {
 		return "jsonSchema7";
 	}
 	shouldApply() {
+		if (this.getModel().modelId.includes("claude")) return false;
 		return this.getModel().provider.includes("google") || this.getModel().modelId.includes("gemini-") || this.getModel().modelId.includes("google");
 	}
 	processZodType(value) {