"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }


var _chunkJ54M5MSRcjs = require('./chunk-J54M5MSR.cjs');

// src/serialization/resources/dataSink/index.ts
var dataSink_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, dataSink_exports, {
  DataSinkUpdate: () => DataSinkUpdate,
  DataSinkUpdateComponent: () => DataSinkUpdateComponent,
  DataSinkUpdateComponentOne: () => DataSinkUpdateComponentOne
});

// src/core/fetcher/Fetcher.ts
var _formdata = require('form-data'); var _formdata2 = _interopRequireDefault(_formdata);
var _qs = require('qs'); var _qs2 = _interopRequireDefault(_qs);
var INITIAL_RETRY_DELAY = 1;
var MAX_RETRY_DELAY = 60;
var DEFAULT_MAX_RETRIES = 2;
async function fetcherImpl(args) {
  const headers = {};
  if (args.body !== void 0 && args.contentType != null) {
    headers["Content-Type"] = args.contentType;
  }
  if (args.headers != null) {
    for (const [key, value] of Object.entries(args.headers)) {
      if (value != null) {
        headers[key] = value;
      }
    }
  }
  const url = Object.keys(_nullishCoalesce(args.queryParameters, () => ( {}))).length > 0 ? `${args.url}?${_qs2.default.stringify(args.queryParameters, { arrayFormat: "repeat" })}` : args.url;
  let body = void 0;
  if (args.body instanceof _formdata2.default) {
    body = args.body;
  } else {
    body = JSON.stringify(args.body);
  }
  const fetchFn = typeof fetch == "function" ? fetch : _chunkJ54M5MSRcjs.__require.call(void 0, "node-fetch");
  const makeRequest = async () => {
    const controller = new AbortController();
    let abortId = void 0;
    if (args.timeoutMs != null) {
      abortId = setTimeout(() => controller.abort(), args.timeoutMs);
    }
    const response = await fetchFn(url, {
      method: args.method,
      headers,
      body,
      signal: controller.signal,
      credentials: args.withCredentials ? "include" : void 0
    });
    if (abortId != null) {
      clearTimeout(abortId);
    }
    return response;
  };
  try {
    let response = await makeRequest();
    for (let i = 0; i < (_nullishCoalesce(args.maxRetries, () => ( DEFAULT_MAX_RETRIES))); ++i) {
      if (response.status === 408 || response.status === 409 || response.status === 429 || response.status >= 500) {
        const delay = Math.min(INITIAL_RETRY_DELAY * Math.pow(i, 2), MAX_RETRY_DELAY);
        await new Promise((resolve) => setTimeout(resolve, delay));
        response = await makeRequest();
      } else {
        break;
      }
    }
    let body2;
    if (response.body != null && args.responseType === "blob") {
      body2 = await response.blob();
    } else if (response.body != null && args.responseType === "streaming") {
      body2 = response.body;
    } else {
      const text = await response.text();
      if (text.length > 0) {
        try {
          body2 = JSON.parse(text);
        } catch (err) {
          return {
            ok: false,
            error: {
              reason: "non-json",
              statusCode: response.status,
              rawBody: text
            }
          };
        }
      }
    }
    if (response.status >= 200 && response.status < 400) {
      return {
        ok: true,
        body: body2,
        headers: response.headers
      };
    } else {
      return {
        ok: false,
        error: {
          reason: "status-code",
          statusCode: response.status,
          body: body2
        }
      };
    }
  } catch (error) {
    if (error instanceof Error && error.name === "AbortError") {
      return {
        ok: false,
        error: {
          reason: "timeout"
        }
      };
    } else if (error instanceof Error) {
      return {
        ok: false,
        error: {
          reason: "unknown",
          errorMessage: error.message
        }
      };
    }
    return {
      ok: false,
      error: {
        reason: "unknown",
        errorMessage: JSON.stringify(error)
      }
    };
  }
}
var fetcher = fetcherImpl;

// src/core/fetcher/Supplier.ts
var Supplier = {
  get: async (supplier) => {
    if (typeof supplier === "function") {
      return supplier();
    } else {
      return supplier;
    }
  }
};

// src/core/auth/BasicAuth.ts
var _jsbase64 = require('js-base64');

// src/core/schemas/index.ts
var schemas_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, schemas_exports, {
  JsonError: () => JsonError,
  ParseError: () => ParseError,
  any: () => any,
  boolean: () => boolean,
  booleanLiteral: () => booleanLiteral,
  date: () => date,
  discriminant: () => discriminant,
  enum_: () => enum_,
  getObjectLikeUtils: () => getObjectLikeUtils,
  getObjectUtils: () => getObjectUtils,
  getSchemaUtils: () => getSchemaUtils,
  isProperty: () => isProperty,
  lazy: () => lazy,
  lazyObject: () => lazyObject,
  list: () => list,
  number: () => number,
  object: () => object,
  objectWithoutOptionalProperties: () => objectWithoutOptionalProperties,
  optional: () => optional,
  property: () => property,
  record: () => record,
  set: () => set,
  string: () => string,
  stringLiteral: () => stringLiteral,
  transform: () => transform,
  undiscriminatedUnion: () => undiscriminatedUnion,
  union: () => union,
  unknown: () => unknown,
  withParsedProperties: () => withParsedProperties
});

// src/core/schemas/Schema.ts
var SchemaType = {
  DATE: "date",
  ENUM: "enum",
  LIST: "list",
  STRING_LITERAL: "stringLiteral",
  BOOLEAN_LITERAL: "booleanLiteral",
  OBJECT: "object",
  ANY: "any",
  BOOLEAN: "boolean",
  NUMBER: "number",
  STRING: "string",
  UNKNOWN: "unknown",
  RECORD: "record",
  SET: "set",
  UNION: "union",
  UNDISCRIMINATED_UNION: "undiscriminatedUnion",
  OPTIONAL: "optional"
};

// src/core/schemas/utils/getErrorMessageForIncorrectType.ts
function getErrorMessageForIncorrectType(value, expectedType) {
  return `Expected ${expectedType}. Received ${getTypeAsString(value)}.`;
}
function getTypeAsString(value) {
  if (Array.isArray(value)) {
    return "list";
  }
  if (value === null) {
    return "null";
  }
  switch (typeof value) {
    case "string":
      return `"${value}"`;
    case "number":
    case "boolean":
    case "undefined":
      return `${value}`;
  }
  return typeof value;
}

// src/core/schemas/utils/maybeSkipValidation.ts
function maybeSkipValidation(schema) {
  return {
    ...schema,
    json: transformAndMaybeSkipValidation(schema.json),
    parse: transformAndMaybeSkipValidation(schema.parse)
  };
}
function transformAndMaybeSkipValidation(transform2) {
  return async (value, opts) => {
    const transformed = await transform2(value, opts);
    const { skipValidation = false } = _nullishCoalesce(opts, () => ( {}));
    if (!transformed.ok && skipValidation) {
      console.warn(
        [
          "Failed to validate.",
          ...transformed.errors.map(
            (error) => "  - " + (error.path.length > 0 ? `${error.path.join(".")}: ${error.message}` : error.message)
          )
        ].join("\n")
      );
      return {
        ok: true,
        value
      };
    } else {
      return transformed;
    }
  };
}

// src/core/schemas/builders/schema-utils/stringifyValidationErrors.ts
function stringifyValidationError(error) {
  if (error.path.length === 0) {
    return error.message;
  }
  return `${error.path.join(" -> ")}: ${error.message}`;
}

// src/core/schemas/builders/schema-utils/JsonError.ts
var JsonError = class _JsonError extends Error {
  constructor(errors) {
    super(errors.map(stringifyValidationError).join("; "));
    this.errors = errors;
    Object.setPrototypeOf(this, _JsonError.prototype);
  }
};

// src/core/schemas/builders/schema-utils/ParseError.ts
var ParseError = class _ParseError extends Error {
  constructor(errors) {
    super(errors.map(stringifyValidationError).join("; "));
    this.errors = errors;
    Object.setPrototypeOf(this, _ParseError.prototype);
  }
};

// src/core/schemas/builders/schema-utils/getSchemaUtils.ts
function getSchemaUtils(schema) {
  return {
    optional: () => optional(schema),
    transform: (transformer) => transform(schema, transformer),
    parseOrThrow: async (raw, opts) => {
      const parsed = await schema.parse(raw, opts);
      if (parsed.ok) {
        return parsed.value;
      }
      throw new ParseError(parsed.errors);
    },
    jsonOrThrow: async (parsed, opts) => {
      const raw = await schema.json(parsed, opts);
      if (raw.ok) {
        return raw.value;
      }
      throw new JsonError(raw.errors);
    }
  };
}
function optional(schema) {
  const baseSchema = {
    parse: (raw, opts) => {
      if (raw == null) {
        return {
          ok: true,
          value: void 0
        };
      }
      return schema.parse(raw, opts);
    },
    json: (parsed, opts) => {
      if (parsed == null) {
        return {
          ok: true,
          value: null
        };
      }
      return schema.json(parsed, opts);
    },
    getType: () => SchemaType.OPTIONAL
  };
  return {
    ...baseSchema,
    ...getSchemaUtils(baseSchema)
  };
}
function transform(schema, transformer) {
  const baseSchema = {
    parse: async (raw, opts) => {
      const parsed = await schema.parse(raw, opts);
      if (!parsed.ok) {
        return parsed;
      }
      return {
        ok: true,
        value: transformer.transform(parsed.value)
      };
    },
    json: async (transformed, opts) => {
      const parsed = await transformer.untransform(transformed);
      return schema.json(parsed, opts);
    },
    getType: () => schema.getType()
  };
  return {
    ...baseSchema,
    ...getSchemaUtils(baseSchema)
  };
}

// src/core/schemas/builders/date/date.ts
var ISO_8601_REGEX = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
function date() {
  const baseSchema = {
    parse: (raw, { breadcrumbsPrefix = [] } = {}) => {
      if (typeof raw !== "string") {
        return {
          ok: false,
          errors: [
            {
              path: breadcrumbsPrefix,
              message: getErrorMessageForIncorrectType(raw, "string")
            }
          ]
        };
      }
      if (!ISO_8601_REGEX.test(raw)) {
        return {
          ok: false,
          errors: [
            {
              path: breadcrumbsPrefix,
              message: getErrorMessageForIncorrectType(raw, "ISO 8601 date string")
            }
          ]
        };
      }
      return {
        ok: true,
        value: new Date(raw)
      };
    },
    json: (date2, { breadcrumbsPrefix = [] } = {}) => {
      if (date2 instanceof Date) {
        return {
          ok: true,
          value: date2.toISOString()
        };
      } else {
        return {
          ok: false,
          errors: [
            {
              path: breadcrumbsPrefix,
              message: getErrorMessageForIncorrectType(date2, "Date object")
            }
          ]
        };
      }
    },
    getType: () => SchemaType.DATE
  };
  return {
    ...maybeSkipValidation(baseSchema),
    ...getSchemaUtils(baseSchema)
  };
}

// src/core/schemas/utils/createIdentitySchemaCreator.ts
function createIdentitySchemaCreator(schemaType, validate) {
  return () => {
    const baseSchema = {
      parse: validate,
      json: validate,
      getType: () => schemaType
    };
    return {
      ...maybeSkipValidation(baseSchema),
      ...getSchemaUtils(baseSchema)
    };
  };
}

// src/core/schemas/builders/enum/enum.ts
function enum_(values) {
  const validValues = new Set(values);
  const schemaCreator = createIdentitySchemaCreator(
    SchemaType.ENUM,
    (value, { allowUnrecognizedEnumValues, breadcrumbsPrefix = [] } = {}) => {
      if (typeof value !== "string") {
        return {
          ok: false,
          errors: [
            {
              path: breadcrumbsPrefix,
              message: getErrorMessageForIncorrectType(value, "string")
            }
          ]
        };
      }
      if (!validValues.has(value) && !allowUnrecognizedEnumValues) {
        return {
          ok: false,
          errors: [
            {
              path: breadcrumbsPrefix,
              message: getErrorMessageForIncorrectType(value, "enum")
            }
          ]
        };
      }
      return {
        ok: true,
        value
      };
    }
  );
  return schemaCreator();
}

// src/core/schemas/builders/lazy/lazy.ts
function lazy(getter) {
  const baseSchema = constructLazyBaseSchema(getter);
  return {
    ...baseSchema,
    ...getSchemaUtils(baseSchema)
  };
}
function constructLazyBaseSchema(getter) {
  return {
    parse: async (raw, opts) => (await getMemoizedSchema(getter)).parse(raw, opts),
    json: async (parsed, opts) => (await getMemoizedSchema(getter)).json(parsed, opts),
    getType: async () => (await getMemoizedSchema(getter)).getType()
  };
}
async function getMemoizedSchema(getter) {
  const castedGetter = getter;
  if (castedGetter.__zurg_memoized == null) {
    castedGetter.__zurg_memoized = await getter();
  }
  return castedGetter.__zurg_memoized;
}

// src/core/schemas/utils/entries.ts
function entries(object2) {
  return Object.entries(object2);
}

// src/core/schemas/utils/filterObject.ts
function filterObject(obj, keysToInclude) {
  const keysToIncludeSet = new Set(keysToInclude);
  return Object.entries(obj).reduce((acc, [key, value]) => {
    if (keysToIncludeSet.has(key)) {
      acc[key] = value;
    }
    return acc;
  }, {});
}

// src/core/schemas/utils/isPlainObject.ts
function isPlainObject(value) {
  if (typeof value !== "object" || value === null) {
    return false;
  }
  if (Object.getPrototypeOf(value) === null) {
    return true;
  }
  let proto = value;
  while (Object.getPrototypeOf(proto) !== null) {
    proto = Object.getPrototypeOf(proto);
  }
  return Object.getPrototypeOf(value) === proto;
}

// src/core/schemas/utils/keys.ts
function keys(object2) {
  return Object.keys(object2);
}

// src/core/schemas/utils/partition.ts
function partition(items, predicate) {
  const trueItems = [], falseItems = [];
  for (const item of items) {
    if (predicate(item)) {
      trueItems.push(item);
    } else {
      falseItems.push(item);
    }
  }
  return [trueItems, falseItems];
}

// src/core/schemas/builders/object-like/getObjectLikeUtils.ts
function getObjectLikeUtils(schema) {
  return {
    withParsedProperties: (properties) => withParsedProperties(schema, properties)
  };
}
function withParsedProperties(objectLike, properties) {
  const objectSchema = {
    parse: async (raw, opts) => {
      const parsedObject = await objectLike.parse(raw, opts);
      if (!parsedObject.ok) {
        return parsedObject;
      }
      const additionalProperties = Object.entries(properties).reduce(
        (processed, [key, value]) => {
          return {
            ...processed,
            [key]: typeof value === "function" ? value(parsedObject.value) : value
          };
        },
        {}
      );
      return {
        ok: true,
        value: {
          ...parsedObject.value,
          ...additionalProperties
        }
      };
    },
    json: (parsed, opts) => {
      if (!isPlainObject(parsed)) {
        return {
          ok: false,
          errors: [
            {
              path: _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _ => _.breadcrumbsPrefix]), () => ( [])),
              message: getErrorMessageForIncorrectType(parsed, "object")
            }
          ]
        };
      }
      const addedPropertyKeys = new Set(Object.keys(properties));
      const parsedWithoutAddedProperties = filterObject(
        parsed,
        Object.keys(parsed).filter((key) => !addedPropertyKeys.has(key))
      );
      return objectLike.json(parsedWithoutAddedProperties, opts);
    },
    getType: () => objectLike.getType()
  };
  return {
    ...objectSchema,
    ...getSchemaUtils(objectSchema),
    ...getObjectLikeUtils(objectSchema)
  };
}

// src/core/schemas/builders/object/property.ts
function property(rawKey, valueSchema) {
  return {
    rawKey,
    valueSchema,
    isProperty: true
  };
}
function isProperty(maybeProperty) {
  return maybeProperty.isProperty;
}

// src/core/schemas/builders/object/object.ts
function object(schemas) {
  const baseSchema = {
    _getRawProperties: () => Promise.resolve(
      Object.entries(schemas).map(
        ([parsedKey, propertySchema]) => isProperty(propertySchema) ? propertySchema.rawKey : parsedKey
      )
    ),
    _getParsedProperties: () => Promise.resolve(keys(schemas)),
    parse: async (raw, opts) => {
      const rawKeyToProperty = {};
      const requiredKeys = [];
      for (const [parsedKey, schemaOrObjectProperty] of entries(schemas)) {
        const rawKey = isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.rawKey : parsedKey;
        const valueSchema = isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.valueSchema : schemaOrObjectProperty;
        const property2 = {
          rawKey,
          parsedKey,
          valueSchema
        };
        rawKeyToProperty[rawKey] = property2;
        if (await isSchemaRequired(valueSchema)) {
          requiredKeys.push(rawKey);
        }
      }
      return validateAndTransformObject({
        value: raw,
        requiredKeys,
        getProperty: (rawKey) => {
          const property2 = rawKeyToProperty[rawKey];
          if (property2 == null) {
            return void 0;
          }
          return {
            transformedKey: property2.parsedKey,
            transform: (propertyValue) => property2.valueSchema.parse(propertyValue, {
              ...opts,
              breadcrumbsPrefix: [..._nullishCoalesce(_optionalChain([opts, 'optionalAccess', _2 => _2.breadcrumbsPrefix]), () => ( [])), rawKey]
            })
          };
        },
        unrecognizedObjectKeys: _optionalChain([opts, 'optionalAccess', _3 => _3.unrecognizedObjectKeys]),
        skipValidation: _optionalChain([opts, 'optionalAccess', _4 => _4.skipValidation]),
        breadcrumbsPrefix: _optionalChain([opts, 'optionalAccess', _5 => _5.breadcrumbsPrefix])
      });
    },
    json: async (parsed, opts) => {
      const requiredKeys = [];
      for (const [parsedKey, schemaOrObjectProperty] of entries(schemas)) {
        const valueSchema = isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.valueSchema : schemaOrObjectProperty;
        if (await isSchemaRequired(valueSchema)) {
          requiredKeys.push(parsedKey);
        }
      }
      return validateAndTransformObject({
        value: parsed,
        requiredKeys,
        getProperty: (parsedKey) => {
          const property2 = schemas[parsedKey];
          if (property2 == null) {
            return void 0;
          }
          if (isProperty(property2)) {
            return {
              transformedKey: property2.rawKey,
              transform: (propertyValue) => property2.valueSchema.json(propertyValue, {
                ...opts,
                breadcrumbsPrefix: [..._nullishCoalesce(_optionalChain([opts, 'optionalAccess', _6 => _6.breadcrumbsPrefix]), () => ( [])), parsedKey]
              })
            };
          } else {
            return {
              transformedKey: parsedKey,
              transform: (propertyValue) => property2.json(propertyValue, {
                ...opts,
                breadcrumbsPrefix: [..._nullishCoalesce(_optionalChain([opts, 'optionalAccess', _7 => _7.breadcrumbsPrefix]), () => ( [])), parsedKey]
              })
            };
          }
        },
        unrecognizedObjectKeys: _optionalChain([opts, 'optionalAccess', _8 => _8.unrecognizedObjectKeys]),
        skipValidation: _optionalChain([opts, 'optionalAccess', _9 => _9.skipValidation]),
        breadcrumbsPrefix: _optionalChain([opts, 'optionalAccess', _10 => _10.breadcrumbsPrefix])
      });
    },
    getType: () => SchemaType.OBJECT
  };
  return {
    ...maybeSkipValidation(baseSchema),
    ...getSchemaUtils(baseSchema),
    ...getObjectLikeUtils(baseSchema),
    ...getObjectUtils(baseSchema)
  };
}
async function validateAndTransformObject({
  value,
  requiredKeys,
  getProperty,
  unrecognizedObjectKeys = "fail",
  skipValidation = false,
  breadcrumbsPrefix = []
}) {
  if (!isPlainObject(value)) {
    return {
      ok: false,
      errors: [
        {
          path: breadcrumbsPrefix,
          message: getErrorMessageForIncorrectType(value, "object")
        }
      ]
    };
  }
  const missingRequiredKeys = new Set(requiredKeys);
  const errors = [];
  const transformed = {};
  for (const [preTransformedKey, preTransformedItemValue] of Object.entries(value)) {
    const property2 = getProperty(preTransformedKey);
    if (property2 != null) {
      missingRequiredKeys.delete(preTransformedKey);
      const value2 = await property2.transform(preTransformedItemValue);
      if (value2.ok) {
        transformed[property2.transformedKey] = value2.value;
      } else {
        transformed[preTransformedKey] = preTransformedItemValue;
        errors.push(...value2.errors);
      }
    } else {
      switch (unrecognizedObjectKeys) {
        case "fail":
          errors.push({
            path: [...breadcrumbsPrefix, preTransformedKey],
            message: `Unexpected key "${preTransformedKey}"`
          });
          break;
        case "strip":
          break;
        case "passthrough":
          transformed[preTransformedKey] = preTransformedItemValue;
          break;
      }
    }
  }
  errors.push(
    ...requiredKeys.filter((key) => missingRequiredKeys.has(key)).map((key) => ({
      path: breadcrumbsPrefix,
      message: `Missing required key "${key}"`
    }))
  );
  if (errors.length === 0 || skipValidation) {
    return {
      ok: true,
      value: transformed
    };
  } else {
    return {
      ok: false,
      errors
    };
  }
}
function getObjectUtils(schema) {
  return {
    extend: (extension) => {
      const baseSchema = {
        _getParsedProperties: async () => [
          ...await schema._getParsedProperties(),
          ...await extension._getParsedProperties()
        ],
        _getRawProperties: async () => [
          ...await schema._getRawProperties(),
          ...await extension._getRawProperties()
        ],
        parse: async (raw, opts) => {
          return validateAndTransformExtendedObject({
            extensionKeys: await extension._getRawProperties(),
            value: raw,
            transformBase: (rawBase) => schema.parse(rawBase, opts),
            transformExtension: (rawExtension) => extension.parse(rawExtension, opts)
          });
        },
        json: async (parsed, opts) => {
          return validateAndTransformExtendedObject({
            extensionKeys: await extension._getParsedProperties(),
            value: parsed,
            transformBase: (parsedBase) => schema.json(parsedBase, opts),
            transformExtension: (parsedExtension) => extension.json(parsedExtension, opts)
          });
        },
        getType: () => SchemaType.OBJECT
      };
      return {
        ...baseSchema,
        ...getSchemaUtils(baseSchema),
        ...getObjectLikeUtils(baseSchema),
        ...getObjectUtils(baseSchema)
      };
    }
  };
}
async function validateAndTransformExtendedObject({
  extensionKeys,
  value,
  transformBase,
  transformExtension
}) {
  const extensionPropertiesSet = new Set(extensionKeys);
  const [extensionProperties, baseProperties] = partition(
    keys(value),
    (key) => extensionPropertiesSet.has(key)
  );
  const transformedBase = await transformBase(filterObject(value, baseProperties));
  const transformedExtension = await transformExtension(filterObject(value, extensionProperties));
  if (transformedBase.ok && transformedExtension.ok) {
    return {
      ok: true,
      value: {
        ...transformedBase.value,
        ...transformedExtension.value
      }
    };
  } else {
    return {
      ok: false,
      errors: [
        ...transformedBase.ok ? [] : transformedBase.errors,
        ...transformedExtension.ok ? [] : transformedExtension.errors
      ]
    };
  }
}
async function isSchemaRequired(schema) {
  return !await isSchemaOptional(schema);
}
async function isSchemaOptional(schema) {
  switch (await schema.getType()) {
    case SchemaType.ANY:
    case SchemaType.UNKNOWN:
    case SchemaType.OPTIONAL:
      return true;
    default:
      return false;
  }
}

// src/core/schemas/builders/object/objectWithoutOptionalProperties.ts
function objectWithoutOptionalProperties(schemas) {
  return object(schemas);
}

// src/core/schemas/builders/lazy/lazyObject.ts
function lazyObject(getter) {
  const baseSchema = {
    ...constructLazyBaseSchema(getter),
    _getRawProperties: async () => (await getMemoizedSchema(getter))._getRawProperties(),
    _getParsedProperties: async () => (await getMemoizedSchema(getter))._getParsedProperties()
  };
  return {
    ...baseSchema,
    ...getSchemaUtils(baseSchema),
    ...getObjectLikeUtils(baseSchema),
    ...getObjectUtils(baseSchema)
  };
}

// src/core/schemas/builders/list/list.ts
function list(schema) {
  const baseSchema = {
    parse: async (raw, opts) => validateAndTransformArray(
      raw,
      (item, index) => schema.parse(item, {
        ...opts,
        breadcrumbsPrefix: [..._nullishCoalesce(_optionalChain([opts, 'optionalAccess', _11 => _11.breadcrumbsPrefix]), () => ( [])), `[${index}]`]
      })
    ),
    json: (parsed, opts) => validateAndTransformArray(
      parsed,
      (item, index) => schema.json(item, {
        ...opts,
        breadcrumbsPrefix: [..._nullishCoalesce(_optionalChain([opts, 'optionalAccess', _12 => _12.breadcrumbsPrefix]), () => ( [])), `[${index}]`]
      })
    ),
    getType: () => SchemaType.LIST
  };
  return {
    ...maybeSkipValidation(baseSchema),
    ...getSchemaUtils(baseSchema)
  };
}
async function validateAndTransformArray(value, transformItem) {
  if (!Array.isArray(value)) {
    return {
      ok: false,
      errors: [
        {
          message: getErrorMessageForIncorrectType(value, "list"),
          path: []
        }
      ]
    };
  }
  const maybeValidItems = await Promise.all(value.map((item, index) => transformItem(item, index)));
  return maybeValidItems.reduce(
    (acc, item) => {
      if (acc.ok && item.ok) {
        return {
          ok: true,
          value: [...acc.value, item.value]
        };
      }
      const errors = [];
      if (!acc.ok) {
        errors.push(...acc.errors);
      }
      if (!item.ok) {
        errors.push(...item.errors);
      }
      return {
        ok: false,
        errors
      };
    },
    { ok: true, value: [] }
  );
}

// src/core/schemas/builders/literals/stringLiteral.ts
function stringLiteral(literal) {
  const schemaCreator = createIdentitySchemaCreator(
    SchemaType.STRING_LITERAL,
    (value, { breadcrumbsPrefix = [] } = {}) => {
      if (value === literal) {
        return {
          ok: true,
          value: literal
        };
      } else {
        return {
          ok: false,
          errors: [
            {
              path: breadcrumbsPrefix,
              message: getErrorMessageForIncorrectType(value, `"${literal}"`)
            }
          ]
        };
      }
    }
  );
  return schemaCreator();
}

// src/core/schemas/builders/literals/booleanLiteral.ts
function booleanLiteral(literal) {
  const schemaCreator = createIdentitySchemaCreator(
    SchemaType.BOOLEAN_LITERAL,
    (value, { breadcrumbsPrefix = [] } = {}) => {
      if (value === literal) {
        return {
          ok: true,
          value: literal
        };
      } else {
        return {
          ok: false,
          errors: [
            {
              path: breadcrumbsPrefix,
              message: getErrorMessageForIncorrectType(value, `${literal.toString()}`)
            }
          ]
        };
      }
    }
  );
  return schemaCreator();
}

// src/core/schemas/builders/primitives/any.ts
var any = createIdentitySchemaCreator(SchemaType.ANY, (value) => ({ ok: true, value }));

// src/core/schemas/builders/primitives/boolean.ts
var boolean = createIdentitySchemaCreator(
  SchemaType.BOOLEAN,
  (value, { breadcrumbsPrefix = [] } = {}) => {
    if (typeof value === "boolean") {
      return {
        ok: true,
        value
      };
    } else {
      return {
        ok: false,
        errors: [
          {
            path: breadcrumbsPrefix,
            message: getErrorMessageForIncorrectType(value, "boolean")
          }
        ]
      };
    }
  }
);

// src/core/schemas/builders/primitives/number.ts
var number = createIdentitySchemaCreator(
  SchemaType.NUMBER,
  (value, { breadcrumbsPrefix = [] } = {}) => {
    if (typeof value === "number") {
      return {
        ok: true,
        value
      };
    } else {
      return {
        ok: false,
        errors: [
          {
            path: breadcrumbsPrefix,
            message: getErrorMessageForIncorrectType(value, "number")
          }
        ]
      };
    }
  }
);

// src/core/schemas/builders/primitives/string.ts
var string = createIdentitySchemaCreator(
  SchemaType.STRING,
  (value, { breadcrumbsPrefix = [] } = {}) => {
    if (typeof value === "string") {
      return {
        ok: true,
        value
      };
    } else {
      return {
        ok: false,
        errors: [
          {
            path: breadcrumbsPrefix,
            message: getErrorMessageForIncorrectType(value, "string")
          }
        ]
      };
    }
  }
);

// src/core/schemas/builders/primitives/unknown.ts
var unknown = createIdentitySchemaCreator(SchemaType.UNKNOWN, (value) => ({ ok: true, value }));

// src/core/schemas/builders/record/record.ts
function record(keySchema, valueSchema) {
  const baseSchema = {
    parse: async (raw, opts) => {
      return validateAndTransformRecord({
        value: raw,
        isKeyNumeric: await keySchema.getType() === SchemaType.NUMBER,
        transformKey: (key) => keySchema.parse(key, {
          ...opts,
          breadcrumbsPrefix: [..._nullishCoalesce(_optionalChain([opts, 'optionalAccess', _13 => _13.breadcrumbsPrefix]), () => ( [])), `${key} (key)`]
        }),
        transformValue: (value, key) => valueSchema.parse(value, {
          ...opts,
          breadcrumbsPrefix: [..._nullishCoalesce(_optionalChain([opts, 'optionalAccess', _14 => _14.breadcrumbsPrefix]), () => ( [])), `${key}`]
        }),
        breadcrumbsPrefix: _optionalChain([opts, 'optionalAccess', _15 => _15.breadcrumbsPrefix])
      });
    },
    json: async (parsed, opts) => {
      return validateAndTransformRecord({
        value: parsed,
        isKeyNumeric: await keySchema.getType() === SchemaType.NUMBER,
        transformKey: (key) => keySchema.json(key, {
          ...opts,
          breadcrumbsPrefix: [..._nullishCoalesce(_optionalChain([opts, 'optionalAccess', _16 => _16.breadcrumbsPrefix]), () => ( [])), `${key} (key)`]
        }),
        transformValue: (value, key) => valueSchema.json(value, {
          ...opts,
          breadcrumbsPrefix: [..._nullishCoalesce(_optionalChain([opts, 'optionalAccess', _17 => _17.breadcrumbsPrefix]), () => ( [])), `${key}`]
        }),
        breadcrumbsPrefix: _optionalChain([opts, 'optionalAccess', _18 => _18.breadcrumbsPrefix])
      });
    },
    getType: () => SchemaType.RECORD
  };
  return {
    ...maybeSkipValidation(baseSchema),
    ...getSchemaUtils(baseSchema)
  };
}
async function validateAndTransformRecord({
  value,
  isKeyNumeric,
  transformKey,
  transformValue,
  breadcrumbsPrefix = []
}) {
  if (!isPlainObject(value)) {
    return {
      ok: false,
      errors: [
        {
          path: breadcrumbsPrefix,
          message: getErrorMessageForIncorrectType(value, "object")
        }
      ]
    };
  }
  return entries(value).reduce(
    async (accPromise, [stringKey, value2]) => {
      if (value2 == null) {
        return accPromise;
      }
      const acc = await accPromise;
      let key = stringKey;
      if (isKeyNumeric) {
        const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
        if (!isNaN(numberKey)) {
          key = numberKey;
        }
      }
      const transformedKey = await transformKey(key);
      const transformedValue = await transformValue(value2, key);
      if (acc.ok && transformedKey.ok && transformedValue.ok) {
        return {
          ok: true,
          value: {
            ...acc.value,
            [transformedKey.value]: transformedValue.value
          }
        };
      }
      const errors = [];
      if (!acc.ok) {
        errors.push(...acc.errors);
      }
      if (!transformedKey.ok) {
        errors.push(...transformedKey.errors);
      }
      if (!transformedValue.ok) {
        errors.push(...transformedValue.errors);
      }
      return {
        ok: false,
        errors
      };
    },
    Promise.resolve({ ok: true, value: {} })
  );
}

// src/core/schemas/builders/set/set.ts
function set(schema) {
  const listSchema = list(schema);
  const baseSchema = {
    parse: async (raw, opts) => {
      const parsedList = await listSchema.parse(raw, opts);
      if (parsedList.ok) {
        return {
          ok: true,
          value: new Set(parsedList.value)
        };
      } else {
        return parsedList;
      }
    },
    json: async (parsed, opts) => {
      if (!(parsed instanceof Set)) {
        return {
          ok: false,
          errors: [
            {
              path: _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _19 => _19.breadcrumbsPrefix]), () => ( [])),
              message: getErrorMessageForIncorrectType(parsed, "Set")
            }
          ]
        };
      }
      const jsonList = await listSchema.json([...parsed], opts);
      return jsonList;
    },
    getType: () => SchemaType.SET
  };
  return {
    ...maybeSkipValidation(baseSchema),
    ...getSchemaUtils(baseSchema)
  };
}

// src/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.ts
function undiscriminatedUnion(schemas) {
  const baseSchema = {
    parse: async (raw, opts) => {
      return validateAndTransformUndiscriminatedUnion(
        (schema, opts2) => schema.parse(raw, opts2),
        schemas,
        opts
      );
    },
    json: async (parsed, opts) => {
      return validateAndTransformUndiscriminatedUnion(
        (schema, opts2) => schema.json(parsed, opts2),
        schemas,
        opts
      );
    },
    getType: () => SchemaType.UNDISCRIMINATED_UNION
  };
  return {
    ...maybeSkipValidation(baseSchema),
    ...getSchemaUtils(baseSchema)
  };
}
async function validateAndTransformUndiscriminatedUnion(transform2, schemas, opts) {
  const errors = [];
  for (const [index, schema] of schemas.entries()) {
    const transformed = await transform2(schema, { ...opts, skipValidation: false });
    if (transformed.ok) {
      return transformed;
    } else {
      for (const error of transformed.errors) {
        errors.push({
          path: error.path,
          message: `[Variant ${index}] ${error.message}`
        });
      }
    }
  }
  return {
    ok: false,
    errors
  };
}

// src/core/schemas/builders/union/discriminant.ts
function discriminant(parsedDiscriminant, rawDiscriminant) {
  return {
    parsedDiscriminant,
    rawDiscriminant
  };
}

// src/core/schemas/builders/union/union.ts
function union(discriminant2, union2) {
  const rawDiscriminant = typeof discriminant2 === "string" ? discriminant2 : discriminant2.rawDiscriminant;
  const parsedDiscriminant = typeof discriminant2 === "string" ? discriminant2 : discriminant2.parsedDiscriminant;
  const discriminantValueSchema = enum_(keys(union2));
  const baseSchema = {
    parse: async (raw, opts) => {
      return transformAndValidateUnion({
        value: raw,
        discriminant: rawDiscriminant,
        transformedDiscriminant: parsedDiscriminant,
        transformDiscriminantValue: (discriminantValue) => discriminantValueSchema.parse(discriminantValue, {
          allowUnrecognizedEnumValues: _optionalChain([opts, 'optionalAccess', _20 => _20.allowUnrecognizedUnionMembers]),
          breadcrumbsPrefix: [..._nullishCoalesce(_optionalChain([opts, 'optionalAccess', _21 => _21.breadcrumbsPrefix]), () => ( [])), rawDiscriminant]
        }),
        getAdditionalPropertiesSchema: (discriminantValue) => union2[discriminantValue],
        allowUnrecognizedUnionMembers: _optionalChain([opts, 'optionalAccess', _22 => _22.allowUnrecognizedUnionMembers]),
        transformAdditionalProperties: (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.parse(additionalProperties, opts),
        breadcrumbsPrefix: _optionalChain([opts, 'optionalAccess', _23 => _23.breadcrumbsPrefix])
      });
    },
    json: async (parsed, opts) => {
      return transformAndValidateUnion({
        value: parsed,
        discriminant: parsedDiscriminant,
        transformedDiscriminant: rawDiscriminant,
        transformDiscriminantValue: (discriminantValue) => discriminantValueSchema.json(discriminantValue, {
          allowUnrecognizedEnumValues: _optionalChain([opts, 'optionalAccess', _24 => _24.allowUnrecognizedUnionMembers]),
          breadcrumbsPrefix: [..._nullishCoalesce(_optionalChain([opts, 'optionalAccess', _25 => _25.breadcrumbsPrefix]), () => ( [])), parsedDiscriminant]
        }),
        getAdditionalPropertiesSchema: (discriminantValue) => union2[discriminantValue],
        allowUnrecognizedUnionMembers: _optionalChain([opts, 'optionalAccess', _26 => _26.allowUnrecognizedUnionMembers]),
        transformAdditionalProperties: (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.json(additionalProperties, opts),
        breadcrumbsPrefix: _optionalChain([opts, 'optionalAccess', _27 => _27.breadcrumbsPrefix])
      });
    },
    getType: () => SchemaType.UNION
  };
  return {
    ...maybeSkipValidation(baseSchema),
    ...getSchemaUtils(baseSchema),
    ...getObjectLikeUtils(baseSchema)
  };
}
async function transformAndValidateUnion({
  value,
  discriminant: discriminant2,
  transformedDiscriminant,
  transformDiscriminantValue,
  getAdditionalPropertiesSchema,
  allowUnrecognizedUnionMembers = false,
  transformAdditionalProperties,
  breadcrumbsPrefix = []
}) {
  if (!isPlainObject(value)) {
    return {
      ok: false,
      errors: [
        {
          path: breadcrumbsPrefix,
          message: getErrorMessageForIncorrectType(value, "object")
        }
      ]
    };
  }
  const { [discriminant2]: discriminantValue, ...additionalProperties } = value;
  if (discriminantValue == null) {
    return {
      ok: false,
      errors: [
        {
          path: breadcrumbsPrefix,
          message: `Missing discriminant ("${discriminant2}")`
        }
      ]
    };
  }
  const transformedDiscriminantValue = await transformDiscriminantValue(discriminantValue);
  if (!transformedDiscriminantValue.ok) {
    return {
      ok: false,
      errors: transformedDiscriminantValue.errors
    };
  }
  const additionalPropertiesSchema = getAdditionalPropertiesSchema(transformedDiscriminantValue.value);
  if (additionalPropertiesSchema == null) {
    if (allowUnrecognizedUnionMembers) {
      return {
        ok: true,
        value: {
          [transformedDiscriminant]: transformedDiscriminantValue.value,
          ...additionalProperties
        }
      };
    } else {
      return {
        ok: false,
        errors: [
          {
            path: [...breadcrumbsPrefix, discriminant2],
            message: "Unexpected discriminant value"
          }
        ]
      };
    }
  }
  const transformedAdditionalProperties = await transformAdditionalProperties(
    additionalProperties,
    additionalPropertiesSchema
  );
  if (!transformedAdditionalProperties.ok) {
    return transformedAdditionalProperties;
  }
  return {
    ok: true,
    value: {
      [transformedDiscriminant]: discriminantValue,
      ...transformedAdditionalProperties.value
    }
  };
}

// src/serialization/resources/dataSink/types/DataSinkUpdateComponentOne.ts
var DataSinkUpdateComponentOne = schemas_exports.undiscriminatedUnion([
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ChromaVectorStore),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PineconeVectorStore),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PgVectorStore),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).QdrantVectorStore),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).WeaviateVectorStore)
]);

// src/serialization/resources/dataSink/types/DataSinkUpdateComponent.ts
var DataSinkUpdateComponent = schemas_exports.undiscriminatedUnion([
  schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()),
  schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSinkUpdateComponentOne)
]);

// src/serialization/resources/dataSink/client/requests/DataSinkUpdate.ts
var DataSinkUpdate = schemas_exports.object({
  name: schemas_exports.string().optional(),
  sinkType: schemas_exports.property(
    "sink_type",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfigurableDataSinkNames)
  ),
  component: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSinkUpdateComponent).optional()
});

// src/serialization/resources/dataSource/index.ts
var dataSource_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, dataSource_exports, {
  DataSourceUpdate: () => DataSourceUpdate,
  DataSourceUpdateComponent: () => DataSourceUpdateComponent,
  DataSourceUpdateComponentOne: () => DataSourceUpdateComponentOne,
  getDataSourceExecutions: () => getDataSourceExecutions_exports
});

// src/serialization/resources/dataSource/types/DataSourceUpdateComponentOne.ts
var DataSourceUpdateComponentOne = schemas_exports.undiscriminatedUnion([
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ReaderConfig),
  schemas_exports.unknown(),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).TextNode),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).Document)
]);

// src/serialization/resources/dataSource/types/DataSourceUpdateComponent.ts
var DataSourceUpdateComponent = schemas_exports.undiscriminatedUnion([
  schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()),
  schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSourceUpdateComponentOne),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ExternallyStoredComponent)
]);

// src/serialization/resources/dataSource/client/getDataSourceExecutions.ts
var getDataSourceExecutions_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getDataSourceExecutions_exports, {
  Response: () => Response
});
var Response = schemas_exports.list(
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSourceLoadJobRecord)
);

// src/serialization/resources/dataSource/client/requests/DataSourceUpdate.ts
var DataSourceUpdate = schemas_exports.object({
  name: schemas_exports.string().optional(),
  sourceType: schemas_exports.property(
    "source_type",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfigurableDataSourceNames)
  ),
  component: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSourceUpdateComponent).optional()
});

// src/serialization/resources/health/index.ts
var health_exports2 = {};
_chunkJ54M5MSRcjs.__export.call(void 0, health_exports2, {
  health: () => health_exports
});

// src/serialization/resources/health/client/health.ts
var health_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, health_exports, {
  Response: () => Response2
});
var Response2 = schemas_exports.record(schemas_exports.string(), schemas_exports.string());

// src/serialization/resources/apiKey/index.ts
var apiKey_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, apiKey_exports, {
  ApiKeyCreate: () => ApiKeyCreate,
  ApiKeyUpdate: () => ApiKeyUpdate,
  getKeys: () => getKeys_exports
});

// src/serialization/resources/apiKey/client/getKeys.ts
var getKeys_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getKeys_exports, {
  Response: () => Response3
});
var Response3 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ApiKey));

// src/serialization/resources/apiKey/client/requests/ApiKeyCreate.ts
var ApiKeyCreate = schemas_exports.object({
  name: schemas_exports.string().optional()
});

// src/serialization/resources/apiKey/client/requests/ApiKeyUpdate.ts
var ApiKeyUpdate = schemas_exports.object({
  name: schemas_exports.string().optional()
});

// src/serialization/resources/project/index.ts
var project_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, project_exports, {
  EvalDatasetCreate: () => EvalDatasetCreate,
  LocalEvalSetCreate: () => LocalEvalSetCreate,
  ProjectUpdate: () => ProjectUpdate,
  createLocalEvalSetForProject: () => createLocalEvalSetForProject_exports,
  getDatasetsForProject: () => getDatasetsForProject_exports,
  getLocalEvalSetsForProject: () => getLocalEvalSetsForProject_exports,
  getLocalEvalsForProject: () => getLocalEvalsForProject_exports,
  getPromptmixinPrompts: () => getPromptmixinPrompts_exports,
  listProjects: () => listProjects_exports
});

// src/serialization/resources/project/client/listProjects.ts
var listProjects_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, listProjects_exports, {
  Response: () => Response4
});
var Response4 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).Project));

// src/serialization/resources/project/client/getDatasetsForProject.ts
var getDatasetsForProject_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getDatasetsForProject_exports, {
  Response: () => Response5
});
var Response5 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).EvalDataset));

// src/serialization/resources/project/client/createLocalEvalSetForProject.ts
var createLocalEvalSetForProject_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, createLocalEvalSetForProject_exports, {
  Response: () => Response6
});
var Response6 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).LocalEvalResults));

// src/serialization/resources/project/client/getLocalEvalsForProject.ts
var getLocalEvalsForProject_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getLocalEvalsForProject_exports, {
  Response: () => Response7
});
var Response7 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).LocalEvalResults));

// src/serialization/resources/project/client/getLocalEvalSetsForProject.ts
var getLocalEvalSetsForProject_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getLocalEvalSetsForProject_exports, {
  Response: () => Response8
});
var Response8 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).LocalEvalSets));

// src/serialization/resources/project/client/getPromptmixinPrompts.ts
var getPromptmixinPrompts_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getPromptmixinPrompts_exports, {
  Response: () => Response9
});
var Response9 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PromptMixinPrompts));

// src/serialization/resources/project/client/requests/ProjectUpdate.ts
var ProjectUpdate = schemas_exports.object({
  name: schemas_exports.string()
});

// src/serialization/resources/project/client/requests/EvalDatasetCreate.ts
var EvalDatasetCreate = schemas_exports.object({
  name: schemas_exports.string()
});

// src/serialization/resources/project/client/requests/LocalEvalSetCreate.ts
var LocalEvalSetCreate = schemas_exports.object({
  appName: schemas_exports.property("app_name", schemas_exports.string()),
  results: schemas_exports.record(
    schemas_exports.string(),
    schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).LocalEval))
  )
});

// src/serialization/resources/pipeline/index.ts
var pipeline_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, pipeline_exports, {
  EvalExecutionCreate: () => EvalExecutionCreate,
  PipelineUpdate: () => PipelineUpdate,
  RetrievalParams: () => RetrievalParams,
  getAllPlaygroundJobs: () => getAllPlaygroundJobs_exports,
  getEvalDatasetExecutionResult: () => getEvalDatasetExecutionResult_exports,
  getEvalDatasetExecutions: () => getEvalDatasetExecutions_exports,
  getLoadedFilesForPipeline: () => getLoadedFilesForPipeline_exports,
  getManagedDataSourceIngestionExecutions: () => getManagedDataSourceIngestionExecutions_exports,
  getManagedPipelineIngestionExecutions: () => getManagedPipelineIngestionExecutions_exports,
  getPlaygroundJobResult: () => getPlaygroundJobResult_exports,
  getRawFileManagedIngestionExecutions: () => getRawFileManagedIngestionExecutions_exports,
  readRawFiles: () => readRawFiles_exports,
  searchPipelines: () => searchPipelines_exports
});

// src/serialization/resources/pipeline/client/searchPipelines.ts
var searchPipelines_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, searchPipelines_exports, {
  Response: () => Response10
});
var Response10 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).Pipeline));

// src/serialization/resources/pipeline/client/getLoadedFilesForPipeline.ts
var getLoadedFilesForPipeline_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getLoadedFilesForPipeline_exports, {
  Response: () => Response11
});
var Response11 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).LoadedFile));

// src/serialization/resources/pipeline/client/getAllPlaygroundJobs.ts
var getAllPlaygroundJobs_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getAllPlaygroundJobs_exports, {
  Response: () => Response12
});
var Response12 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PlaygroundJobRecord));

// src/serialization/resources/pipeline/client/getPlaygroundJobResult.ts
var getPlaygroundJobResult_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getPlaygroundJobResult_exports, {
  Response: () => Response13
});
var Response13 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PlatformTextNode));

// src/serialization/resources/pipeline/client/getEvalDatasetExecutions.ts
var getEvalDatasetExecutions_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getEvalDatasetExecutions_exports, {
  Response: () => Response14
});
var Response14 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).EvalDatasetJobRecord));

// src/serialization/resources/pipeline/client/getEvalDatasetExecutionResult.ts
var getEvalDatasetExecutionResult_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getEvalDatasetExecutionResult_exports, {
  Response: () => Response15
});
var Response15 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).EvalQuestionResult));

// src/serialization/resources/pipeline/client/getRawFileManagedIngestionExecutions.ts
var getRawFileManagedIngestionExecutions_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getRawFileManagedIngestionExecutions_exports, {
  Response: () => Response16
});
var Response16 = schemas_exports.list(
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).RawFileManagedIngestionJobRecord)
);

// src/serialization/resources/pipeline/client/getManagedDataSourceIngestionExecutions.ts
var getManagedDataSourceIngestionExecutions_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getManagedDataSourceIngestionExecutions_exports, {
  Response: () => Response17
});
var Response17 = schemas_exports.list(
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSourceManagedIngestionJobRecord)
);

// src/serialization/resources/pipeline/client/getManagedPipelineIngestionExecutions.ts
var getManagedPipelineIngestionExecutions_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getManagedPipelineIngestionExecutions_exports, {
  Response: () => Response18
});
var Response18 = schemas_exports.list(
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PipelineManagedIngestionJobRecord)
);

// src/serialization/resources/pipeline/client/readRawFiles.ts
var readRawFiles_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, readRawFiles_exports, {
  Response: () => Response19
});
var Response19 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).RawFile));

// src/serialization/resources/pipeline/client/requests/PipelineUpdate.ts
var PipelineUpdate = schemas_exports.object({
  configuredTransformations: schemas_exports.property(
    "configured_transformations",
    schemas_exports.list(
      schemas_exports.lazyObject(
        async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfiguredTransformationItem
      )
    ).optional()
  ),
  dataSourceIds: schemas_exports.property(
    "data_source_ids",
    schemas_exports.list(schemas_exports.string()).optional()
  ),
  dataSources: schemas_exports.property(
    "data_sources",
    schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSourceCreate)).optional()
  ),
  dataSinkIds: schemas_exports.property(
    "data_sink_ids",
    schemas_exports.list(schemas_exports.string()).optional()
  ),
  dataSinks: schemas_exports.property(
    "data_sinks",
    schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSinkCreate)).optional()
  ),
  rawFileNames: schemas_exports.property(
    "raw_file_names",
    schemas_exports.list(schemas_exports.string()).optional()
  ),
  presetRetrievalParameters: schemas_exports.property(
    "preset_retrieval_parameters",
    schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PresetRetrievalParams).optional()
  ),
  evalParameters: schemas_exports.property(
    "eval_parameters",
    schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).EvalExecutionParams).optional()
  ),
  llamaParseEnabled: schemas_exports.property("llama_parse_enabled", schemas_exports.boolean().optional()),
  name: schemas_exports.string().optional(),
  managedPipelineId: schemas_exports.property("managed_pipeline_id", schemas_exports.string().optional())
});

// src/serialization/resources/pipeline/client/requests/EvalExecutionCreate.ts
var EvalExecutionCreate = schemas_exports.object({
  evalQuestionIds: schemas_exports.property(
    "eval_question_ids",
    schemas_exports.list(schemas_exports.string())
  ),
  params: schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).EvalExecutionParamsOverride).optional()
});

// src/serialization/resources/pipeline/client/requests/RetrievalParams.ts
var RetrievalParams = schemas_exports.object({
  denseSimilarityTopK: schemas_exports.property(
    "dense_similarity_top_k",
    schemas_exports.number().optional()
  ),
  sparseSimilarityTopK: schemas_exports.property(
    "sparse_similarity_top_k",
    schemas_exports.number().optional()
  ),
  enableReranking: schemas_exports.property("enable_reranking", schemas_exports.boolean().optional()),
  rerankTopN: schemas_exports.property("rerank_top_n", schemas_exports.number().optional()),
  alpha: schemas_exports.number().optional(),
  searchFilters: schemas_exports.property(
    "search_filters",
    schemas_exports.record(schemas_exports.string(), schemas_exports.list(schemas_exports.unknown())).optional()
  ),
  query: schemas_exports.string(),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/resources/eval/index.ts
var eval_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, eval_exports, {
  EvalDatasetUpdate: () => EvalDatasetUpdate,
  createQuestions: () => createQuestions_exports,
  getQuestions: () => getQuestions_exports,
  getSupportedModels: () => getSupportedModels_exports
});

// src/serialization/resources/eval/client/getQuestions.ts
var getQuestions_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getQuestions_exports, {
  Response: () => Response20
});
var Response20 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).EvalQuestion));

// src/serialization/resources/eval/client/createQuestions.ts
var createQuestions_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, createQuestions_exports, {
  Request: () => Request,
  Response: () => Response21
});
var Request = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).EvalQuestionCreate));
var Response21 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).EvalQuestion));

// src/serialization/resources/eval/client/getSupportedModels.ts
var getSupportedModels_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getSupportedModels_exports, {
  Response: () => Response22
});
var Response22 = schemas_exports.list(
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).SupportedEvalLlmModel)
);

// src/serialization/resources/eval/client/requests/EvalDatasetUpdate.ts
var EvalDatasetUpdate = schemas_exports.object({
  name: schemas_exports.string()
});

// src/serialization/resources/parsing/index.ts
var parsing_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, parsing_exports, {
  getSupportedFileExtensions: () => getSupportedFileExtensions_exports
});

// src/serialization/resources/parsing/client/getSupportedFileExtensions.ts
var getSupportedFileExtensions_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getSupportedFileExtensions_exports, {
  Response: () => Response23
});
var Response23 = schemas_exports.list(
  schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).LlamaParseSupportedFileExtensions)
);

// src/serialization/resources/componentDefinition/index.ts
var componentDefinition_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, componentDefinition_exports, {
  getAllDataSinkDefinitions: () => getAllDataSinkDefinitions_exports,
  getAllDataSourceDefinitions: () => getAllDataSourceDefinitions_exports,
  getAllTransformationDefinitions: () => getAllTransformationDefinitions_exports
});

// src/serialization/resources/componentDefinition/client/getAllTransformationDefinitions.ts
var getAllTransformationDefinitions_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getAllTransformationDefinitions_exports, {
  Response: () => Response24
});
var Response24 = schemas_exports.list(
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfigurableTransformationDefinition)
);

// src/serialization/resources/componentDefinition/client/getAllDataSourceDefinitions.ts
var getAllDataSourceDefinitions_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getAllDataSourceDefinitions_exports, {
  Response: () => Response25
});
var Response25 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSourceDefinition));

// src/serialization/resources/componentDefinition/client/getAllDataSinkDefinitions.ts
var getAllDataSinkDefinitions_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, getAllDataSinkDefinitions_exports, {
  Response: () => Response26
});
var Response26 = schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSinkDefinition));

// src/serialization/resources/billing/index.ts
var billing_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, billing_exports, {
  CheckoutSessionCreatePayload: () => CheckoutSessionCreatePayload,
  CustomerPortalSessionCreatePayload: () => CustomerPortalSessionCreatePayload,
  createCheckoutSession: () => createCheckoutSession_exports,
  createCustomerPortalSession: () => createCustomerPortalSession_exports
});

// src/serialization/resources/billing/client/createCheckoutSession.ts
var createCheckoutSession_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, createCheckoutSession_exports, {
  Response: () => Response27
});
var Response27 = schemas_exports.string();

// src/serialization/resources/billing/client/createCustomerPortalSession.ts
var createCustomerPortalSession_exports = {};
_chunkJ54M5MSRcjs.__export.call(void 0, createCustomerPortalSession_exports, {
  Response: () => Response28
});
var Response28 = schemas_exports.string();

// src/serialization/resources/billing/client/requests/CheckoutSessionCreatePayload.ts
var CheckoutSessionCreatePayload = schemas_exports.object({
  successUrl: schemas_exports.property("success_url", schemas_exports.string()),
  cancelUrl: schemas_exports.property("cancel_url", schemas_exports.string())
});

// src/serialization/resources/billing/client/requests/CustomerPortalSessionCreatePayload.ts
var CustomerPortalSessionCreatePayload = schemas_exports.object({
  returnUrl: schemas_exports.property("return_url", schemas_exports.string())
});

// src/serialization/types/ApiKey.ts
var ApiKey = schemas_exports.object({
  id: schemas_exports.string(),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  name: schemas_exports.string().optional(),
  userId: schemas_exports.property("user_id", schemas_exports.string()),
  redactedApiKey: schemas_exports.property("redacted_api_key", schemas_exports.string())
});

// src/serialization/types/AzureOpenAiEmbedding.ts
var AzureOpenAiEmbedding = schemas_exports.object({
  modelName: schemas_exports.property("model_name", schemas_exports.string().optional()),
  embedBatchSize: schemas_exports.property("embed_batch_size", schemas_exports.number().optional()),
  callbackManager: schemas_exports.property(
    "callback_manager",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  additionalKwargs: schemas_exports.property(
    "additional_kwargs",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  apiKey: schemas_exports.property("api_key", schemas_exports.string()),
  apiBase: schemas_exports.property("api_base", schemas_exports.string().optional()),
  apiVersion: schemas_exports.property("api_version", schemas_exports.string().optional()),
  maxRetries: schemas_exports.property("max_retries", schemas_exports.number().optional()),
  timeout: schemas_exports.number().optional(),
  defaultHeaders: schemas_exports.property(
    "default_headers",
    schemas_exports.record(schemas_exports.string(), schemas_exports.string()).optional()
  ),
  reuseClient: schemas_exports.property("reuse_client", schemas_exports.boolean().optional()),
  dimensions: schemas_exports.number().optional(),
  azureEndpoint: schemas_exports.property("azure_endpoint", schemas_exports.string().optional()),
  azureDeployment: schemas_exports.property("azure_deployment", schemas_exports.string().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/BasePydanticReader.ts
var BasePydanticReader = schemas_exports.object({
  isRemote: schemas_exports.property("is_remote", schemas_exports.boolean().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/BeautifulSoupWebReader.ts
var BeautifulSoupWebReader = schemas_exports.object({
  isRemote: schemas_exports.property("is_remote", schemas_exports.boolean().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/ChatMessage.ts
var ChatMessage = schemas_exports.object({
  role: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).MessageRole).optional(),
  content: schemas_exports.unknown().optional(),
  additionalKwargs: schemas_exports.property(
    "additional_kwargs",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  )
});

// src/serialization/types/ChromaVectorStore.ts
var ChromaVectorStore = schemas_exports.object({
  storesText: schemas_exports.property("stores_text", schemas_exports.boolean().optional()),
  isEmbeddingQuery: schemas_exports.property("is_embedding_query", schemas_exports.boolean().optional()),
  flatMetadata: schemas_exports.property("flat_metadata", schemas_exports.boolean().optional()),
  collectionName: schemas_exports.property("collection_name", schemas_exports.string().optional()),
  host: schemas_exports.string().optional(),
  port: schemas_exports.string().optional(),
  ssl: schemas_exports.boolean(),
  headers: schemas_exports.record(schemas_exports.string(), schemas_exports.string()).optional(),
  persistDir: schemas_exports.property("persist_dir", schemas_exports.string().optional()),
  collectionKwargs: schemas_exports.property(
    "collection_kwargs",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/CodeSplitter.ts
var CodeSplitter = schemas_exports.object({
  includeMetadata: schemas_exports.property("include_metadata", schemas_exports.boolean().optional()),
  includePrevNextRel: schemas_exports.property(
    "include_prev_next_rel",
    schemas_exports.boolean().optional()
  ),
  callbackManager: schemas_exports.property(
    "callback_manager",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  language: schemas_exports.string(),
  chunkLines: schemas_exports.property("chunk_lines", schemas_exports.number().optional()),
  chunkLinesOverlap: schemas_exports.property("chunk_lines_overlap", schemas_exports.number().optional()),
  maxChars: schemas_exports.property("max_chars", schemas_exports.number().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/ConfigurableDataSinkNames.ts
var ConfigurableDataSinkNames = schemas_exports.enum_(["CHROMA", "PINECONE", "POSTGRES", "QDRANT", "WEAVIATE"]);

// src/serialization/types/ConfigurableDataSourceNames.ts
var ConfigurableDataSourceNames = schemas_exports.enum_([
  "DISCORD",
  "NOTION_PAGE",
  "SLACK",
  "SIMPLE_WEB_PAGE",
  "TRAFILATURA_WEB_PAGE",
  "BEAUTIFUL_SOUP_WEB_PAGE",
  "RSS",
  "YOUTUBE_TRANSCRIPT",
  "GOOGLE_DOCS",
  "GOOGLE_SHEETS",
  "S3",
  "READER",
  "DOCUMENT_GROUP",
  "TEXT_NODE",
  "DOCUMENT"
]);

// src/serialization/types/ConfigurableTransformationDefinition.ts
var ConfigurableTransformationDefinition = schemas_exports.object({
  label: schemas_exports.string(),
  jsonSchema: schemas_exports.property(
    "json_schema",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown())
  ),
  configurableTransformationType: schemas_exports.property(
    "configurable_transformation_type",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfigurableTransformationNames)
  ),
  transformationCategory: schemas_exports.property(
    "transformation_category",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).TransformationCategoryNames)
  )
});

// src/serialization/types/ConfigurableTransformationNames.ts
var ConfigurableTransformationNames = schemas_exports.enum_([
  "CODE_NODE_PARSER",
  "SENTENCE_AWARE_NODE_PARSER",
  "TOKEN_AWARE_NODE_PARSER",
  "HTML_NODE_PARSER",
  "MARKDOWN_NODE_PARSER",
  "JSON_NODE_PARSER",
  "SIMPLE_FILE_NODE_PARSER",
  "OPENAI_EMBEDDING",
  "AZURE_EMBEDDING"
]);

// src/serialization/types/ConfiguredTransformationItemComponentOne.ts
var ConfiguredTransformationItemComponentOne = schemas_exports.undiscriminatedUnion([
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).CodeSplitter),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).SentenceSplitter),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).TokenTextSplitter),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).HtmlNodeParser),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).MarkdownNodeParser),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).JsonNodeParser),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).SimpleFileNodeParser),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).OpenAiEmbedding),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).AzureOpenAiEmbedding)
]);

// src/serialization/types/ConfiguredTransformationItemComponent.ts
var ConfiguredTransformationItemComponent = schemas_exports.undiscriminatedUnion([
  schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()),
  schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfiguredTransformationItemComponentOne)
]);

// src/serialization/types/ConfiguredTransformationItem.ts
var ConfiguredTransformationItem = schemas_exports.object({
  id: schemas_exports.string().optional(),
  configurableTransformationType: schemas_exports.property(
    "configurable_transformation_type",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfigurableTransformationNames)
  ),
  component: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfiguredTransformationItemComponent)
});

// src/serialization/types/DataSinkComponentOne.ts
var DataSinkComponentOne = schemas_exports.undiscriminatedUnion([
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ChromaVectorStore),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PineconeVectorStore),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PgVectorStore),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).QdrantVectorStore),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).WeaviateVectorStore)
]);

// src/serialization/types/DataSinkComponent.ts
var DataSinkComponent = schemas_exports.undiscriminatedUnion([
  schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()),
  schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSinkComponentOne)
]);

// src/serialization/types/DataSink.ts
var DataSink = schemas_exports.object({
  id: schemas_exports.string(),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  name: schemas_exports.string(),
  sinkType: schemas_exports.property(
    "sink_type",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfigurableDataSinkNames)
  ),
  component: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSinkComponent)
});

// src/serialization/types/DataSinkCreateComponentOne.ts
var DataSinkCreateComponentOne = schemas_exports.undiscriminatedUnion([
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ChromaVectorStore),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PineconeVectorStore),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PgVectorStore),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).QdrantVectorStore),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).WeaviateVectorStore)
]);

// src/serialization/types/DataSinkCreateComponent.ts
var DataSinkCreateComponent = schemas_exports.undiscriminatedUnion([
  schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()),
  schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSinkCreateComponentOne)
]);

// src/serialization/types/DataSinkCreate.ts
var DataSinkCreate = schemas_exports.object({
  name: schemas_exports.string(),
  sinkType: schemas_exports.property(
    "sink_type",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfigurableDataSinkNames)
  ),
  component: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSinkCreateComponent)
});

// src/serialization/types/DataSinkDefinition.ts
var DataSinkDefinition = schemas_exports.object({
  label: schemas_exports.string(),
  jsonSchema: schemas_exports.property(
    "json_schema",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown())
  ),
  sinkType: schemas_exports.property(
    "sink_type",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfigurableDataSinkNames)
  )
});

// src/serialization/types/DataSourceComponentOne.ts
var DataSourceComponentOne = schemas_exports.undiscriminatedUnion([
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ReaderConfig),
  schemas_exports.unknown(),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).TextNode),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).Document)
]);

// src/serialization/types/DataSourceComponent.ts
var DataSourceComponent = schemas_exports.undiscriminatedUnion([
  schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()),
  schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSourceComponentOne),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ExternallyStoredComponent)
]);

// src/serialization/types/DataSource.ts
var DataSource = schemas_exports.object({
  id: schemas_exports.string(),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  name: schemas_exports.string(),
  sourceType: schemas_exports.property(
    "source_type",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfigurableDataSourceNames)
  ),
  component: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSourceComponent)
});

// src/serialization/types/DataSourceCreateComponentOne.ts
var DataSourceCreateComponentOne = schemas_exports.undiscriminatedUnion([
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ReaderConfig),
  schemas_exports.unknown(),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).TextNode),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).Document)
]);

// src/serialization/types/DataSourceCreateComponent.ts
var DataSourceCreateComponent = schemas_exports.undiscriminatedUnion([
  schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()),
  schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSourceCreateComponentOne),
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ExternallyStoredComponent)
]);

// src/serialization/types/DataSourceCreate.ts
var DataSourceCreate = schemas_exports.object({
  name: schemas_exports.string(),
  sourceType: schemas_exports.property(
    "source_type",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfigurableDataSourceNames)
  ),
  component: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSourceCreateComponent)
});

// src/serialization/types/DataSourceDefinition.ts
var DataSourceDefinition = schemas_exports.object({
  label: schemas_exports.string(),
  jsonSchema: schemas_exports.property(
    "json_schema",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown())
  ),
  sourceType: schemas_exports.property(
    "source_type",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfigurableDataSourceNames)
  )
});

// src/serialization/types/DataSourceLoadJobRecord.ts
var DataSourceLoadJobRecord = schemas_exports.object({
  id: schemas_exports.string().optional(),
  jobName: schemas_exports.property(
    "job_name",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).JobNames).optional()
  ),
  status: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).StatusEnum),
  startedAt: schemas_exports.property("started_at", schemas_exports.date().optional()),
  endedAt: schemas_exports.property("ended_at", schemas_exports.date().optional()),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  partitions: schemas_exports.record(schemas_exports.string(), schemas_exports.string())
});

// src/serialization/types/DataSourceManagedIngestionJobRecord.ts
var DataSourceManagedIngestionJobRecord = schemas_exports.object({
  id: schemas_exports.string().optional(),
  jobName: schemas_exports.property(
    "job_name",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).JobNames)
  ),
  status: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).StatusEnum),
  startedAt: schemas_exports.property("started_at", schemas_exports.date().optional()),
  endedAt: schemas_exports.property("ended_at", schemas_exports.date().optional()),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  partitions: schemas_exports.record(schemas_exports.string(), schemas_exports.string())
});

// src/serialization/types/DiscordReader.ts
var DiscordReader = schemas_exports.object({
  isRemote: schemas_exports.property("is_remote", schemas_exports.boolean().optional()),
  discordToken: schemas_exports.property("discord_token", schemas_exports.string()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/DocumentRelationshipsValue.ts
var DocumentRelationshipsValue = schemas_exports.undiscriminatedUnion([
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).RelatedNodeInfo),
  schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).RelatedNodeInfo))
]);

// src/serialization/types/Document.ts
var Document = schemas_exports.object({
  docId: schemas_exports.property("doc_id", schemas_exports.string().optional()),
  embedding: schemas_exports.list(schemas_exports.number()).optional(),
  extraInfo: schemas_exports.property(
    "extra_info",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  excludedEmbedMetadataKeys: schemas_exports.property(
    "excluded_embed_metadata_keys",
    schemas_exports.list(schemas_exports.string()).optional()
  ),
  excludedLlmMetadataKeys: schemas_exports.property(
    "excluded_llm_metadata_keys",
    schemas_exports.list(schemas_exports.string()).optional()
  ),
  relationships: schemas_exports.record(
    schemas_exports.string(),
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DocumentRelationshipsValue)
  ).optional(),
  text: schemas_exports.string().optional(),
  startCharIdx: schemas_exports.property("start_char_idx", schemas_exports.number().optional()),
  endCharIdx: schemas_exports.property("end_char_idx", schemas_exports.number().optional()),
  textTemplate: schemas_exports.property("text_template", schemas_exports.string().optional()),
  metadataTemplate: schemas_exports.property("metadata_template", schemas_exports.string().optional()),
  metadataSeperator: schemas_exports.property("metadata_seperator", schemas_exports.string().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/DocumentGroup.ts
var DocumentGroup = schemas_exports.object({
  isRemote: schemas_exports.property("is_remote", schemas_exports.boolean().optional()),
  filePath: schemas_exports.property("file_path", schemas_exports.string()),
  documents: schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).Document)),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/EvalDataset.ts
var EvalDataset = schemas_exports.object({
  id: schemas_exports.string(),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  name: schemas_exports.string(),
  projectId: schemas_exports.property("project_id", schemas_exports.string())
});

// src/serialization/types/EvalDatasetJobRecord.ts
var EvalDatasetJobRecord = schemas_exports.object({
  id: schemas_exports.string().optional(),
  jobName: schemas_exports.property(
    "job_name",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).JobNames)
  ),
  status: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).StatusEnum),
  startedAt: schemas_exports.property("started_at", schemas_exports.date().optional()),
  endedAt: schemas_exports.property("ended_at", schemas_exports.date().optional()),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  partitions: schemas_exports.record(schemas_exports.string(), schemas_exports.string()),
  evalQuestionIds: schemas_exports.property(
    "eval_question_ids",
    schemas_exports.list(schemas_exports.string())
  ),
  evalExecutionParams: schemas_exports.property(
    "eval_execution_params",
    schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).EvalExecutionParams)
  )
});

// src/serialization/types/EvalExecutionParams.ts
var EvalExecutionParams = schemas_exports.object({
  llmModel: schemas_exports.property(
    "llm_model",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).SupportedEvalLlmModelNames).optional()
  ),
  qaPromptTmpl: schemas_exports.property("qa_prompt_tmpl", schemas_exports.string().optional())
});

// src/serialization/types/EvalExecutionParamsOverride.ts
var EvalExecutionParamsOverride = schemas_exports.object({
  llmModel: schemas_exports.property(
    "llm_model",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).SupportedEvalLlmModelNames).optional()
  ),
  qaPromptTmpl: schemas_exports.property("qa_prompt_tmpl", schemas_exports.string().optional())
});

// src/serialization/types/EvalLlmModelData.ts
var EvalLlmModelData = schemas_exports.object({
  name: schemas_exports.string(),
  description: schemas_exports.string()
});

// src/serialization/types/EvalQuestion.ts
var EvalQuestion = schemas_exports.object({
  id: schemas_exports.string(),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  content: schemas_exports.string(),
  evalDatasetId: schemas_exports.property("eval_dataset_id", schemas_exports.string()),
  evalDatasetIndex: schemas_exports.property("eval_dataset_index", schemas_exports.number())
});

// src/serialization/types/EvalQuestionCreate.ts
var EvalQuestionCreate = schemas_exports.object({
  content: schemas_exports.string()
});

// src/serialization/types/EvalQuestionResult.ts
var EvalQuestionResult = schemas_exports.object({
  evalQuestionId: schemas_exports.property("eval_question_id", schemas_exports.string()),
  pipelineId: schemas_exports.property("pipeline_id", schemas_exports.string()),
  sourceNodes: schemas_exports.property(
    "source_nodes",
    schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).TextNode))
  ),
  answer: schemas_exports.string(),
  evalMetrics: schemas_exports.property(
    "eval_metrics",
    schemas_exports.record(
      schemas_exports.string(),
      schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).MetricResult)
    )
  ),
  evalDatasetExecutionId: schemas_exports.property("eval_dataset_execution_id", schemas_exports.string()),
  evalDatasetExecutionParams: schemas_exports.property(
    "eval_dataset_execution_params",
    schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).EvalExecutionParams)
  ),
  evalFinishedAt: schemas_exports.property("eval_finished_at", schemas_exports.date()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/ExternallyStoredComponent.ts
var ExternallyStoredComponent = schemas_exports.object({
  id: schemas_exports.string(),
  extraPathPrefix: schemas_exports.property("extra_path_prefix", schemas_exports.string()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/GoogleDocsReader.ts
var GoogleDocsReader = schemas_exports.object({
  isRemote: schemas_exports.property("is_remote", schemas_exports.boolean().optional()),
  splitOnHeadingLevel: schemas_exports.property("split_on_heading_level", schemas_exports.number().optional()),
  includeToc: schemas_exports.property("include_toc", schemas_exports.boolean().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/GoogleSheetsReader.ts
var GoogleSheetsReader = schemas_exports.object({
  isRemote: schemas_exports.property("is_remote", schemas_exports.boolean().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/HtmlNodeParser.ts
var HtmlNodeParser = schemas_exports.object({
  includeMetadata: schemas_exports.property("include_metadata", schemas_exports.boolean().optional()),
  includePrevNextRel: schemas_exports.property("include_prev_next_rel", schemas_exports.boolean().optional()),
  callbackManager: schemas_exports.property(
    "callback_manager",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  tags: schemas_exports.list(schemas_exports.string()).optional(),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/HttpValidationError.ts
var HttpValidationError = schemas_exports.object({
  detail: schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ValidationError)).optional()
});

// src/serialization/types/JsonNodeParser.ts
var JsonNodeParser = schemas_exports.object({
  includeMetadata: schemas_exports.property("include_metadata", schemas_exports.boolean().optional()),
  includePrevNextRel: schemas_exports.property("include_prev_next_rel", schemas_exports.boolean().optional()),
  callbackManager: schemas_exports.property(
    "callback_manager",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/JobNames.ts
var JobNames = schemas_exports.enum_([
  "load_documents_job",
  "load_raw_files_job",
  "playground_job",
  "eval_dataset_job",
  "pipeline_managed_ingestion_job",
  "data_source_managed_ingestion_job",
  "raw_file_managed_ingestion_job"
]);

// src/serialization/types/LlamaParseSupportedFileExtensions.ts
var LlamaParseSupportedFileExtensions = schemas_exports.enum_([
  ".pdf",
  ".doc",
  ".docx",
  ".docm",
  ".dot",
  ".dotx",
  ".dotm",
  ".rtf",
  ".wps",
  ".wpd",
  ".sxw",
  ".stw",
  ".sxg",
  ".pages",
  ".mw",
  ".mcw",
  ".uot",
  ".uof",
  ".uos",
  ".uop",
  ".ppt",
  ".pptx",
  ".pot",
  ".pptm",
  ".potx",
  ".potm",
  ".key",
  ".odp",
  ".odg",
  ".otp",
  ".fopd",
  ".sxi",
  ".sti",
  ".epub"
]);

// src/serialization/types/LoadedFile.ts
var LoadedFile = schemas_exports.object({
  id: schemas_exports.string(),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  name: schemas_exports.string(),
  fileSize: schemas_exports.property("file_size", schemas_exports.number().optional()),
  fileType: schemas_exports.property("file_type", schemas_exports.string().optional()),
  numPages: schemas_exports.property("num_pages", schemas_exports.number().optional()),
  dataSourceId: schemas_exports.property("data_source_id", schemas_exports.string().optional()),
  rawFileName: schemas_exports.property("raw_file_name", schemas_exports.string().optional()),
  pipelineId: schemas_exports.property("pipeline_id", schemas_exports.string())
});

// src/serialization/types/LoadedFilePayload.ts
var LoadedFilePayload = schemas_exports.object({
  loadedFileId: schemas_exports.property("loaded_file_id", schemas_exports.string()),
  documents: schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).Document)).optional(),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/LocalEval.ts
var LocalEval = schemas_exports.object({
  query: schemas_exports.string().optional(),
  contexts: schemas_exports.list(schemas_exports.string()).optional(),
  response: schemas_exports.string().optional(),
  passing: schemas_exports.boolean().optional(),
  feedback: schemas_exports.string().optional(),
  score: schemas_exports.number().optional(),
  pairwiseSource: schemas_exports.property("pairwise_source", schemas_exports.string().optional()),
  invalidResult: schemas_exports.property("invalid_result", schemas_exports.boolean().optional()),
  invalidReason: schemas_exports.property("invalid_reason", schemas_exports.string().optional())
});

// src/serialization/types/LocalEvalResults.ts
var LocalEvalResults = schemas_exports.object({
  projectId: schemas_exports.property("project_id", schemas_exports.string()),
  evalSetId: schemas_exports.property("eval_set_id", schemas_exports.string().optional()),
  appName: schemas_exports.property("app_name", schemas_exports.string()),
  evalName: schemas_exports.property("eval_name", schemas_exports.string()),
  result: schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).LocalEval)
});

// src/serialization/types/LocalEvalSets.ts
var LocalEvalSets = schemas_exports.object({
  evalSetId: schemas_exports.property("eval_set_id", schemas_exports.string()),
  appName: schemas_exports.property("app_name", schemas_exports.string()),
  uploadTime: schemas_exports.property("upload_time", schemas_exports.date())
});

// src/serialization/types/ManagedIngestionStatus.ts
var ManagedIngestionStatus = schemas_exports.enum_(["NOT_STARTED", "CREATING", "IN_PROGRESS", "SUCCESS", "ERROR"]);

// src/serialization/types/MarkdownNodeParser.ts
var MarkdownNodeParser = schemas_exports.object({
  includeMetadata: schemas_exports.property("include_metadata", schemas_exports.boolean().optional()),
  includePrevNextRel: schemas_exports.property("include_prev_next_rel", schemas_exports.boolean().optional()),
  callbackManager: schemas_exports.property(
    "callback_manager",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/MessageRole.ts
var MessageRole = schemas_exports.enum_(["system", "user", "assistant", "function", "tool", "chatbot", "model"]);

// src/serialization/types/MetricResult.ts
var MetricResult = schemas_exports.object({
  passing: schemas_exports.boolean().optional(),
  score: schemas_exports.number().optional(),
  feedback: schemas_exports.string().optional()
});

// src/serialization/types/NotionPageReader.ts
var NotionPageReader = schemas_exports.object({
  isRemote: schemas_exports.property("is_remote", schemas_exports.boolean().optional()),
  token: schemas_exports.string(),
  headers: schemas_exports.record(schemas_exports.string(), schemas_exports.string()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/ObjectType.ts
var ObjectType = schemas_exports.enum_(["1", "2", "3", "4"]);

// src/serialization/types/OpenAiEmbedding.ts
var OpenAiEmbedding = schemas_exports.object({
  modelName: schemas_exports.property("model_name", schemas_exports.string().optional()),
  embedBatchSize: schemas_exports.property("embed_batch_size", schemas_exports.number().optional()),
  callbackManager: schemas_exports.property(
    "callback_manager",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  additionalKwargs: schemas_exports.property(
    "additional_kwargs",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  apiKey: schemas_exports.property("api_key", schemas_exports.string()),
  apiBase: schemas_exports.property("api_base", schemas_exports.string().optional()),
  apiVersion: schemas_exports.property("api_version", schemas_exports.string().optional()),
  maxRetries: schemas_exports.property("max_retries", schemas_exports.number().optional()),
  timeout: schemas_exports.number().optional(),
  defaultHeaders: schemas_exports.property(
    "default_headers",
    schemas_exports.record(schemas_exports.string(), schemas_exports.string()).optional()
  ),
  reuseClient: schemas_exports.property("reuse_client", schemas_exports.boolean().optional()),
  dimensions: schemas_exports.number().optional(),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/PgVectorStore.ts
var PgVectorStore = schemas_exports.object({
  storesText: schemas_exports.property("stores_text", schemas_exports.boolean().optional()),
  isEmbeddingQuery: schemas_exports.property("is_embedding_query", schemas_exports.boolean().optional()),
  connectionString: schemas_exports.property("connection_string", schemas_exports.string()),
  asyncConnectionString: schemas_exports.property("async_connection_string", schemas_exports.string()),
  tableName: schemas_exports.property("table_name", schemas_exports.string()),
  schemaName: schemas_exports.property("schema_name", schemas_exports.string()),
  embedDim: schemas_exports.property("embed_dim", schemas_exports.number()),
  hybridSearch: schemas_exports.property("hybrid_search", schemas_exports.boolean()),
  textSearchConfig: schemas_exports.property("text_search_config", schemas_exports.string()),
  cacheOk: schemas_exports.property("cache_ok", schemas_exports.boolean()),
  performSetup: schemas_exports.property("perform_setup", schemas_exports.boolean()),
  debug: schemas_exports.boolean(),
  useJsonb: schemas_exports.property("use_jsonb", schemas_exports.boolean()),
  flatMetadata: schemas_exports.property("flat_metadata", schemas_exports.boolean().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/ParserLanguages.ts
var ParserLanguages = schemas_exports.enum_([
  "af",
  "az",
  "bs",
  "cs",
  "cy",
  "da",
  "de",
  "en",
  "es",
  "et",
  "fr",
  "ga",
  "hr",
  "hu",
  "id",
  "is",
  "it",
  "ku",
  "la",
  "lt",
  "lv",
  "mi",
  "ms",
  "mt",
  "nl",
  "no",
  "oc",
  "pi",
  "pl",
  "pt",
  "ro",
  "rs_latin",
  "sk",
  "sl",
  "sq",
  "sv",
  "sw",
  "tl",
  "tr",
  "uz",
  "vi",
  "ar",
  "fa",
  "ug",
  "ur",
  "bn",
  "as",
  "mni",
  "ru",
  "rs_cyrillic",
  "be",
  "bg",
  "uk",
  "mn",
  "abq",
  "ady",
  "kbd",
  "ava",
  "dar",
  "inh",
  "che",
  "lbe",
  "lez",
  "tab",
  "tjk",
  "hi",
  "mr",
  "ne",
  "bh",
  "mai",
  "ang",
  "bho",
  "mah",
  "sck",
  "new",
  "gom",
  "sa",
  "bgc",
  "th",
  "ch_sim",
  "ch_tra",
  "ja",
  "ko",
  "ta",
  "te",
  "kn"
]);

// src/serialization/types/ParsingJob.ts
var ParsingJob = schemas_exports.object({
  id: schemas_exports.string(),
  status: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).StatusEnum)
});

// src/serialization/types/ParsingJobMarkdownResult.ts
var ParsingJobMarkdownResult = schemas_exports.object({
  markdown: schemas_exports.string()
});

// src/serialization/types/ParsingJobTextResult.ts
var ParsingJobTextResult = schemas_exports.object({
  text: schemas_exports.string()
});

// src/serialization/types/ParsingUsage.ts
var ParsingUsage = schemas_exports.object({
  usagePdfPages: schemas_exports.property("usage_pdf_pages", schemas_exports.number()),
  maxPdfPages: schemas_exports.property("max_pdf_pages", schemas_exports.number())
});

// src/serialization/types/PineconeVectorStore.ts
var PineconeVectorStore = schemas_exports.object({
  storesText: schemas_exports.property("stores_text", schemas_exports.boolean().optional()),
  isEmbeddingQuery: schemas_exports.property("is_embedding_query", schemas_exports.boolean().optional()),
  flatMetadata: schemas_exports.property("flat_metadata", schemas_exports.boolean().optional()),
  apiKey: schemas_exports.property("api_key", schemas_exports.string().optional()),
  indexName: schemas_exports.property("index_name", schemas_exports.string().optional()),
  environment: schemas_exports.string().optional(),
  namespace: schemas_exports.string().optional(),
  insertKwargs: schemas_exports.property(
    "insert_kwargs",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  addSparseVector: schemas_exports.property("add_sparse_vector", schemas_exports.boolean()),
  textKey: schemas_exports.property("text_key", schemas_exports.string()),
  batchSize: schemas_exports.property("batch_size", schemas_exports.number()),
  removeTextFromMetadata: schemas_exports.property("remove_text_from_metadata", schemas_exports.boolean()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/Pipeline.ts
var Pipeline = schemas_exports.object({
  configuredTransformations: schemas_exports.property(
    "configured_transformations",
    schemas_exports.list(
      schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfiguredTransformationItem)
    )
  ),
  id: schemas_exports.string(),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  name: schemas_exports.string(),
  projectId: schemas_exports.property("project_id", schemas_exports.string()),
  pipelineType: schemas_exports.property(
    "pipeline_type",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PipelineType).optional()
  ),
  managedPipelineId: schemas_exports.property("managed_pipeline_id", schemas_exports.string().optional()),
  presetRetrievalParameters: schemas_exports.property(
    "preset_retrieval_parameters",
    schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PresetRetrievalParams).optional()
  ),
  evalParameters: schemas_exports.property(
    "eval_parameters",
    schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).EvalExecutionParams).optional()
  ),
  llamaParseEnabled: schemas_exports.property("llama_parse_enabled", schemas_exports.boolean().optional()),
  managedIngestionStatus: schemas_exports.property(
    "managed_ingestion_status",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ManagedIngestionStatus).optional()
  ),
  dataSources: schemas_exports.property(
    "data_sources",
    schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSource))
  ),
  dataSinks: schemas_exports.property(
    "data_sinks",
    schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSink))
  ),
  rawFileNames: schemas_exports.property(
    "raw_file_names",
    schemas_exports.list(schemas_exports.string()).optional()
  )
});

// src/serialization/types/PipelineCreate.ts
var PipelineCreate = schemas_exports.object({
  configuredTransformations: schemas_exports.property(
    "configured_transformations",
    schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ConfiguredTransformationItem)).optional()
  ),
  dataSourceIds: schemas_exports.property(
    "data_source_ids",
    schemas_exports.list(schemas_exports.string()).optional()
  ),
  dataSources: schemas_exports.property(
    "data_sources",
    schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSourceCreate)).optional()
  ),
  dataSinkIds: schemas_exports.property(
    "data_sink_ids",
    schemas_exports.list(schemas_exports.string()).optional()
  ),
  dataSinks: schemas_exports.property(
    "data_sinks",
    schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).DataSinkCreate)).optional()
  ),
  rawFileNames: schemas_exports.property(
    "raw_file_names",
    schemas_exports.list(schemas_exports.string()).optional()
  ),
  presetRetrievalParameters: schemas_exports.property(
    "preset_retrieval_parameters",
    schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PresetRetrievalParams).optional()
  ),
  evalParameters: schemas_exports.property(
    "eval_parameters",
    schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).EvalExecutionParams).optional()
  ),
  llamaParseEnabled: schemas_exports.property("llama_parse_enabled", schemas_exports.boolean().optional()),
  name: schemas_exports.string(),
  pipelineType: schemas_exports.property(
    "pipeline_type",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PipelineType).optional()
  ),
  managedPipelineId: schemas_exports.property("managed_pipeline_id", schemas_exports.string().optional())
});

// src/serialization/types/PipelineManagedIngestionJobRecord.ts
var PipelineManagedIngestionJobRecord = schemas_exports.object({
  id: schemas_exports.string().optional(),
  jobName: schemas_exports.property(
    "job_name",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).JobNames)
  ),
  status: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).StatusEnum),
  startedAt: schemas_exports.property("started_at", schemas_exports.date().optional()),
  endedAt: schemas_exports.property("ended_at", schemas_exports.date().optional()),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  partitions: schemas_exports.record(schemas_exports.string(), schemas_exports.string())
});

// src/serialization/types/PipelineType.ts
var PipelineType = schemas_exports.enum_(["PLAYGROUND", "MANAGED"]);

// src/serialization/types/PlatformTextNodeRelationshipsValue.ts
var PlatformTextNodeRelationshipsValue = schemas_exports.undiscriminatedUnion([
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).RelatedNodeInfo),
  schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).RelatedNodeInfo))
]);

// src/serialization/types/PlatformTextNode.ts
var PlatformTextNode = schemas_exports.object({
  id: schemas_exports.property("id_", schemas_exports.string().optional()),
  embedding: schemas_exports.list(schemas_exports.number()).optional(),
  extraInfo: schemas_exports.property(
    "extra_info",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  excludedEmbedMetadataKeys: schemas_exports.property(
    "excluded_embed_metadata_keys",
    schemas_exports.list(schemas_exports.string()).optional()
  ),
  excludedLlmMetadataKeys: schemas_exports.property(
    "excluded_llm_metadata_keys",
    schemas_exports.list(schemas_exports.string()).optional()
  ),
  relationships: schemas_exports.record(
    schemas_exports.string(),
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PlatformTextNodeRelationshipsValue)
  ).optional(),
  text: schemas_exports.string().optional(),
  startCharIdx: schemas_exports.property("start_char_idx", schemas_exports.number().optional()),
  endCharIdx: schemas_exports.property("end_char_idx", schemas_exports.number().optional()),
  textTemplate: schemas_exports.property("text_template", schemas_exports.string().optional()),
  metadataTemplate: schemas_exports.property("metadata_template", schemas_exports.string().optional()),
  metadataSeperator: schemas_exports.property("metadata_seperator", schemas_exports.string().optional()),
  pipelineId: schemas_exports.property("pipeline_id", schemas_exports.string()),
  configuredTransformationId: schemas_exports.property(
    "configured_transformation_id",
    schemas_exports.string()
  ),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/PlaygroundJobRecord.ts
var PlaygroundJobRecord = schemas_exports.object({
  id: schemas_exports.string().optional(),
  jobName: schemas_exports.property(
    "job_name",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).JobNames)
  ),
  status: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).StatusEnum),
  startedAt: schemas_exports.property("started_at", schemas_exports.date().optional()),
  endedAt: schemas_exports.property("ended_at", schemas_exports.date().optional()),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  partitions: schemas_exports.record(schemas_exports.string(), schemas_exports.string()),
  loadedFileIds: schemas_exports.property(
    "loaded_file_ids",
    schemas_exports.list(schemas_exports.string()).optional()
  )
});

// src/serialization/types/PresetRetrievalParams.ts
var PresetRetrievalParams = schemas_exports.object({
  denseSimilarityTopK: schemas_exports.property("dense_similarity_top_k", schemas_exports.number().optional()),
  sparseSimilarityTopK: schemas_exports.property(
    "sparse_similarity_top_k",
    schemas_exports.number().optional()
  ),
  enableReranking: schemas_exports.property("enable_reranking", schemas_exports.boolean().optional()),
  rerankTopN: schemas_exports.property("rerank_top_n", schemas_exports.number().optional()),
  alpha: schemas_exports.number().optional(),
  searchFilters: schemas_exports.property(
    "search_filters",
    schemas_exports.record(schemas_exports.string(), schemas_exports.list(schemas_exports.unknown())).optional()
  ),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/Project.ts
var Project = schemas_exports.object({
  name: schemas_exports.string(),
  id: schemas_exports.string(),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  pipelines: schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).Pipeline)),
  adHocEvalDatasetId: schemas_exports.property(
    "ad_hoc_eval_dataset_id",
    schemas_exports.string().optional()
  ),
  userId: schemas_exports.property("user_id", schemas_exports.string())
});

// src/serialization/types/ProjectCreate.ts
var ProjectCreate = schemas_exports.object({
  name: schemas_exports.string()
});

// src/serialization/types/PromptMixinPrompts.ts
var PromptMixinPrompts = schemas_exports.object({
  projectId: schemas_exports.property("project_id", schemas_exports.string()),
  id: schemas_exports.string().optional(),
  name: schemas_exports.string(),
  prompts: schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).PromptSpec))
});

// src/serialization/types/PromptSpec.ts
var PromptSpec = schemas_exports.object({
  promptKey: schemas_exports.property("prompt_key", schemas_exports.string()),
  promptClass: schemas_exports.property("prompt_class", schemas_exports.string()),
  promptType: schemas_exports.property("prompt_type", schemas_exports.string()),
  template: schemas_exports.string().optional(),
  messageTemplates: schemas_exports.property(
    "message_templates",
    schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ChatMessage)).optional()
  )
});

// src/serialization/types/QdrantVectorStore.ts
var QdrantVectorStore = schemas_exports.object({
  storesText: schemas_exports.property("stores_text", schemas_exports.boolean().optional()),
  isEmbeddingQuery: schemas_exports.property("is_embedding_query", schemas_exports.boolean().optional()),
  flatMetadata: schemas_exports.property("flat_metadata", schemas_exports.boolean().optional()),
  collectionName: schemas_exports.property("collection_name", schemas_exports.string()),
  path: schemas_exports.string().optional(),
  url: schemas_exports.string().optional(),
  apiKey: schemas_exports.property("api_key", schemas_exports.string().optional()),
  batchSize: schemas_exports.property("batch_size", schemas_exports.number()),
  parallel: schemas_exports.number(),
  maxRetries: schemas_exports.property("max_retries", schemas_exports.number()),
  clientKwargs: schemas_exports.property(
    "client_kwargs",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  enableHybrid: schemas_exports.property("enable_hybrid", schemas_exports.boolean()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/RawFile.ts
var RawFile = schemas_exports.object({
  name: schemas_exports.string(),
  fileSize: schemas_exports.property("file_size", schemas_exports.number()),
  fileType: schemas_exports.property("file_type", schemas_exports.string()),
  lastModifiedAt: schemas_exports.property("last_modified_at", schemas_exports.date())
});

// src/serialization/types/RawFileManagedIngestionJobRecord.ts
var RawFileManagedIngestionJobRecord = schemas_exports.object({
  id: schemas_exports.string().optional(),
  jobName: schemas_exports.property(
    "job_name",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).JobNames)
  ),
  status: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).StatusEnum),
  startedAt: schemas_exports.property("started_at", schemas_exports.date().optional()),
  endedAt: schemas_exports.property("ended_at", schemas_exports.date().optional()),
  createdAt: schemas_exports.property("created_at", schemas_exports.date().optional()),
  updatedAt: schemas_exports.property("updated_at", schemas_exports.date().optional()),
  partitions: schemas_exports.record(schemas_exports.string(), schemas_exports.string())
});

// src/serialization/types/ReaderConfig.ts
var ReaderConfig = schemas_exports.object({
  reader: schemas_exports.unknown(),
  readerArgs: schemas_exports.property(
    "reader_args",
    schemas_exports.list(schemas_exports.unknown()).optional()
  ),
  readerKwargs: schemas_exports.property(
    "reader_kwargs",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/RelatedNodeInfo.ts
var RelatedNodeInfo = schemas_exports.object({
  nodeId: schemas_exports.property("node_id", schemas_exports.string()),
  nodeType: schemas_exports.property(
    "node_type",
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ObjectType).optional()
  ),
  metadata: schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional(),
  hash: schemas_exports.string().optional(),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/RetrieveResults.ts
var RetrieveResults = schemas_exports.object({
  pipelineId: schemas_exports.property("pipeline_id", schemas_exports.string()),
  retrievalNodes: schemas_exports.property(
    "retrieval_nodes",
    schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).TextNodeWithScore))
  ),
  retrievalLatency: schemas_exports.property(
    "retrieval_latency",
    schemas_exports.record(schemas_exports.string(), schemas_exports.number())
  ),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/RssReader.ts
var RssReader = schemas_exports.object({
  isRemote: schemas_exports.property("is_remote", schemas_exports.boolean().optional()),
  htmlToText: schemas_exports.property("html_to_text", schemas_exports.boolean().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/S3ReaderFileExtractorValue.ts
var S3ReaderFileExtractorValue = schemas_exports.undiscriminatedUnion([schemas_exports.string(), schemas_exports.unknown()]);

// src/serialization/types/S3Reader.ts
var S3Reader = schemas_exports.object({
  isRemote: schemas_exports.property("is_remote", schemas_exports.boolean().optional()),
  bucket: schemas_exports.string(),
  key: schemas_exports.string().optional(),
  prefix: schemas_exports.string().optional(),
  recursive: schemas_exports.boolean().optional(),
  fileExtractor: schemas_exports.property(
    "file_extractor",
    schemas_exports.record(
      schemas_exports.string(),
      schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).S3ReaderFileExtractorValue)
    ).optional()
  ),
  requiredExts: schemas_exports.property(
    "required_exts",
    schemas_exports.list(schemas_exports.string()).optional()
  ),
  filenameAsId: schemas_exports.property("filename_as_id", schemas_exports.boolean().optional()),
  numFilesLimit: schemas_exports.property("num_files_limit", schemas_exports.number().optional()),
  awsAccessId: schemas_exports.property("aws_access_id", schemas_exports.string().optional()),
  awsAccessSecret: schemas_exports.property("aws_access_secret", schemas_exports.string().optional()),
  awsSessionToken: schemas_exports.property("aws_session_token", schemas_exports.string().optional()),
  s3EndpointUrl: schemas_exports.property("s3_endpoint_url", schemas_exports.string().optional()),
  customReaderPath: schemas_exports.property("custom_reader_path", schemas_exports.string().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/SentenceSplitter.ts
var SentenceSplitter = schemas_exports.object({
  includeMetadata: schemas_exports.property("include_metadata", schemas_exports.boolean().optional()),
  includePrevNextRel: schemas_exports.property("include_prev_next_rel", schemas_exports.boolean().optional()),
  callbackManager: schemas_exports.property(
    "callback_manager",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  chunkSize: schemas_exports.property("chunk_size", schemas_exports.number().optional()),
  chunkOverlap: schemas_exports.property("chunk_overlap", schemas_exports.number().optional()),
  separator: schemas_exports.string().optional(),
  paragraphSeparator: schemas_exports.property("paragraph_separator", schemas_exports.string().optional()),
  secondaryChunkingRegex: schemas_exports.property(
    "secondary_chunking_regex",
    schemas_exports.string().optional()
  ),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/SimpleFileNodeParser.ts
var SimpleFileNodeParser = schemas_exports.object({
  includeMetadata: schemas_exports.property("include_metadata", schemas_exports.boolean().optional()),
  includePrevNextRel: schemas_exports.property("include_prev_next_rel", schemas_exports.boolean().optional()),
  callbackManager: schemas_exports.property(
    "callback_manager",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/SimpleWebPageReader.ts
var SimpleWebPageReader = schemas_exports.object({
  isRemote: schemas_exports.property("is_remote", schemas_exports.boolean().optional()),
  htmlToText: schemas_exports.property("html_to_text", schemas_exports.boolean()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/SlackReader.ts
var SlackReader = schemas_exports.object({
  isRemote: schemas_exports.property("is_remote", schemas_exports.boolean().optional()),
  slackToken: schemas_exports.property("slack_token", schemas_exports.string()),
  earliestDateTimestamp: schemas_exports.property(
    "earliest_date_timestamp",
    schemas_exports.number().optional()
  ),
  latestDateTimestamp: schemas_exports.property("latest_date_timestamp", schemas_exports.number()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/StatusEnum.ts
var StatusEnum = schemas_exports.enum_(["PENDING", "SUCCESS", "ERROR", "CANCELED"]);

// src/serialization/types/SupportedEvalLlmModel.ts
var SupportedEvalLlmModel = schemas_exports.object({
  name: schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).SupportedEvalLlmModelNames),
  details: schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).EvalLlmModelData)
});

// src/serialization/types/SupportedEvalLlmModelNames.ts
var SupportedEvalLlmModelNames = schemas_exports.enum_(["GPT_3_5_TURBO", "GPT_4", "GPT_4_TURBO"]);

// src/serialization/types/TextNodeRelationshipsValue.ts
var TextNodeRelationshipsValue = schemas_exports.undiscriminatedUnion([
  schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).RelatedNodeInfo),
  schemas_exports.list(schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).RelatedNodeInfo))
]);

// src/serialization/types/TextNode.ts
var TextNode = schemas_exports.object({
  id: schemas_exports.property("id_", schemas_exports.string().optional()),
  embedding: schemas_exports.list(schemas_exports.number()).optional(),
  extraInfo: schemas_exports.property(
    "extra_info",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  excludedEmbedMetadataKeys: schemas_exports.property(
    "excluded_embed_metadata_keys",
    schemas_exports.list(schemas_exports.string()).optional()
  ),
  excludedLlmMetadataKeys: schemas_exports.property(
    "excluded_llm_metadata_keys",
    schemas_exports.list(schemas_exports.string()).optional()
  ),
  relationships: schemas_exports.record(
    schemas_exports.string(),
    schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).TextNodeRelationshipsValue)
  ).optional(),
  text: schemas_exports.string().optional(),
  startCharIdx: schemas_exports.property("start_char_idx", schemas_exports.number().optional()),
  endCharIdx: schemas_exports.property("end_char_idx", schemas_exports.number().optional()),
  textTemplate: schemas_exports.property("text_template", schemas_exports.string().optional()),
  metadataTemplate: schemas_exports.property("metadata_template", schemas_exports.string().optional()),
  metadataSeperator: schemas_exports.property("metadata_seperator", schemas_exports.string().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/TextNodeWithScore.ts
var TextNodeWithScore = schemas_exports.object({
  node: schemas_exports.lazyObject(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).TextNode),
  score: schemas_exports.number().optional(),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/TokenTextSplitter.ts
var TokenTextSplitter = schemas_exports.object({
  includeMetadata: schemas_exports.property("include_metadata", schemas_exports.boolean().optional()),
  includePrevNextRel: schemas_exports.property("include_prev_next_rel", schemas_exports.boolean().optional()),
  callbackManager: schemas_exports.property(
    "callback_manager",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  chunkSize: schemas_exports.property("chunk_size", schemas_exports.number().optional()),
  chunkOverlap: schemas_exports.property("chunk_overlap", schemas_exports.number().optional()),
  separator: schemas_exports.string().optional(),
  backupSeparators: schemas_exports.property(
    "backup_separators",
    schemas_exports.list(schemas_exports.unknown()).optional()
  ),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/TrafilaturaWebReader.ts
var TrafilaturaWebReader = schemas_exports.object({
  isRemote: schemas_exports.property("is_remote", schemas_exports.boolean().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/TransformationCategoryNames.ts
var TransformationCategoryNames = schemas_exports.enum_(["NODE_PARSER", "EMBEDDING"]);

// src/serialization/types/ValidationErrorLocItem.ts
var ValidationErrorLocItem = schemas_exports.undiscriminatedUnion([schemas_exports.string(), schemas_exports.number()]);

// src/serialization/types/ValidationError.ts
var ValidationError = schemas_exports.object({
  loc: schemas_exports.list(schemas_exports.lazy(async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("./serialization-IHRAN5B5.cjs")))).ValidationErrorLocItem)),
  msg: schemas_exports.string(),
  type: schemas_exports.string()
});

// src/serialization/types/WeaviateVectorStore.ts
var WeaviateVectorStore = schemas_exports.object({
  storesText: schemas_exports.property("stores_text", schemas_exports.boolean().optional()),
  isEmbeddingQuery: schemas_exports.property("is_embedding_query", schemas_exports.boolean().optional()),
  indexName: schemas_exports.property("index_name", schemas_exports.string()),
  url: schemas_exports.string().optional(),
  textKey: schemas_exports.property("text_key", schemas_exports.string()),
  authConfig: schemas_exports.property(
    "auth_config",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  clientKwargs: schemas_exports.property(
    "client_kwargs",
    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional()
  ),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});

// src/serialization/types/YoutubeTranscriptReader.ts
var YoutubeTranscriptReader = schemas_exports.object({
  isRemote: schemas_exports.property("is_remote", schemas_exports.boolean().optional()),
  className: schemas_exports.property("class_name", schemas_exports.string().optional())
});










































































































































exports.fetcher = fetcher; exports.Supplier = Supplier; exports.DataSinkUpdateComponentOne = DataSinkUpdateComponentOne; exports.DataSinkUpdateComponent = DataSinkUpdateComponent; exports.DataSinkUpdate = DataSinkUpdate; exports.dataSink_exports = dataSink_exports; exports.DataSourceUpdateComponentOne = DataSourceUpdateComponentOne; exports.DataSourceUpdateComponent = DataSourceUpdateComponent; exports.DataSourceUpdate = DataSourceUpdate; exports.dataSource_exports = dataSource_exports; exports.health_exports = health_exports2; exports.ApiKeyCreate = ApiKeyCreate; exports.ApiKeyUpdate = ApiKeyUpdate; exports.apiKey_exports = apiKey_exports; exports.ProjectUpdate = ProjectUpdate; exports.EvalDatasetCreate = EvalDatasetCreate; exports.LocalEvalSetCreate = LocalEvalSetCreate; exports.project_exports = project_exports; exports.PipelineUpdate = PipelineUpdate; exports.EvalExecutionCreate = EvalExecutionCreate; exports.RetrievalParams = RetrievalParams; exports.pipeline_exports = pipeline_exports; exports.EvalDatasetUpdate = EvalDatasetUpdate; exports.eval_exports = eval_exports; exports.parsing_exports = parsing_exports; exports.componentDefinition_exports = componentDefinition_exports; exports.CheckoutSessionCreatePayload = CheckoutSessionCreatePayload; exports.CustomerPortalSessionCreatePayload = CustomerPortalSessionCreatePayload; exports.billing_exports = billing_exports; exports.ApiKey = ApiKey; exports.AzureOpenAiEmbedding = AzureOpenAiEmbedding; exports.BasePydanticReader = BasePydanticReader; exports.BeautifulSoupWebReader = BeautifulSoupWebReader; exports.ChatMessage = ChatMessage; exports.ChromaVectorStore = ChromaVectorStore; exports.CodeSplitter = CodeSplitter; exports.ConfigurableDataSinkNames = ConfigurableDataSinkNames; exports.ConfigurableDataSourceNames = ConfigurableDataSourceNames; exports.ConfigurableTransformationDefinition = ConfigurableTransformationDefinition; exports.ConfigurableTransformationNames = ConfigurableTransformationNames; exports.ConfiguredTransformationItemComponentOne = ConfiguredTransformationItemComponentOne; exports.ConfiguredTransformationItemComponent = ConfiguredTransformationItemComponent; exports.ConfiguredTransformationItem = ConfiguredTransformationItem; exports.DataSinkComponentOne = DataSinkComponentOne; exports.DataSinkComponent = DataSinkComponent; exports.DataSink = DataSink; exports.DataSinkCreateComponentOne = DataSinkCreateComponentOne; exports.DataSinkCreateComponent = DataSinkCreateComponent; exports.DataSinkCreate = DataSinkCreate; exports.DataSinkDefinition = DataSinkDefinition; exports.DataSourceComponentOne = DataSourceComponentOne; exports.DataSourceComponent = DataSourceComponent; exports.DataSource = DataSource; exports.DataSourceCreateComponentOne = DataSourceCreateComponentOne; exports.DataSourceCreateComponent = DataSourceCreateComponent; exports.DataSourceCreate = DataSourceCreate; exports.DataSourceDefinition = DataSourceDefinition; exports.DataSourceLoadJobRecord = DataSourceLoadJobRecord; exports.DataSourceManagedIngestionJobRecord = DataSourceManagedIngestionJobRecord; exports.DiscordReader = DiscordReader; exports.DocumentRelationshipsValue = DocumentRelationshipsValue; exports.Document = Document; exports.DocumentGroup = DocumentGroup; exports.EvalDataset = EvalDataset; exports.EvalDatasetJobRecord = EvalDatasetJobRecord; exports.EvalExecutionParams = EvalExecutionParams; exports.EvalExecutionParamsOverride = EvalExecutionParamsOverride; exports.EvalLlmModelData = EvalLlmModelData; exports.EvalQuestion = EvalQuestion; exports.EvalQuestionCreate = EvalQuestionCreate; exports.EvalQuestionResult = EvalQuestionResult; exports.ExternallyStoredComponent = ExternallyStoredComponent; exports.GoogleDocsReader = GoogleDocsReader; exports.GoogleSheetsReader = GoogleSheetsReader; exports.HtmlNodeParser = HtmlNodeParser; exports.HttpValidationError = HttpValidationError; exports.JsonNodeParser = JsonNodeParser; exports.JobNames = JobNames; exports.LlamaParseSupportedFileExtensions = LlamaParseSupportedFileExtensions; exports.LoadedFile = LoadedFile; exports.LoadedFilePayload = LoadedFilePayload; exports.LocalEval = LocalEval; exports.LocalEvalResults = LocalEvalResults; exports.LocalEvalSets = LocalEvalSets; exports.ManagedIngestionStatus = ManagedIngestionStatus; exports.MarkdownNodeParser = MarkdownNodeParser; exports.MessageRole = MessageRole; exports.MetricResult = MetricResult; exports.NotionPageReader = NotionPageReader; exports.ObjectType = ObjectType; exports.OpenAiEmbedding = OpenAiEmbedding; exports.PgVectorStore = PgVectorStore; exports.ParserLanguages = ParserLanguages; exports.ParsingJob = ParsingJob; exports.ParsingJobMarkdownResult = ParsingJobMarkdownResult; exports.ParsingJobTextResult = ParsingJobTextResult; exports.ParsingUsage = ParsingUsage; exports.PineconeVectorStore = PineconeVectorStore; exports.Pipeline = Pipeline; exports.PipelineCreate = PipelineCreate; exports.PipelineManagedIngestionJobRecord = PipelineManagedIngestionJobRecord; exports.PipelineType = PipelineType; exports.PlatformTextNodeRelationshipsValue = PlatformTextNodeRelationshipsValue; exports.PlatformTextNode = PlatformTextNode; exports.PlaygroundJobRecord = PlaygroundJobRecord; exports.PresetRetrievalParams = PresetRetrievalParams; exports.Project = Project; exports.ProjectCreate = ProjectCreate; exports.PromptMixinPrompts = PromptMixinPrompts; exports.PromptSpec = PromptSpec; exports.QdrantVectorStore = QdrantVectorStore; exports.RawFile = RawFile; exports.RawFileManagedIngestionJobRecord = RawFileManagedIngestionJobRecord; exports.ReaderConfig = ReaderConfig; exports.RelatedNodeInfo = RelatedNodeInfo; exports.RetrieveResults = RetrieveResults; exports.RssReader = RssReader; exports.S3ReaderFileExtractorValue = S3ReaderFileExtractorValue; exports.S3Reader = S3Reader; exports.SentenceSplitter = SentenceSplitter; exports.SimpleFileNodeParser = SimpleFileNodeParser; exports.SimpleWebPageReader = SimpleWebPageReader; exports.SlackReader = SlackReader; exports.StatusEnum = StatusEnum; exports.SupportedEvalLlmModel = SupportedEvalLlmModel; exports.SupportedEvalLlmModelNames = SupportedEvalLlmModelNames; exports.TextNodeRelationshipsValue = TextNodeRelationshipsValue; exports.TextNode = TextNode; exports.TextNodeWithScore = TextNodeWithScore; exports.TokenTextSplitter = TokenTextSplitter; exports.TrafilaturaWebReader = TrafilaturaWebReader; exports.TransformationCategoryNames = TransformationCategoryNames; exports.ValidationErrorLocItem = ValidationErrorLocItem; exports.ValidationError = ValidationError; exports.WeaviateVectorStore = WeaviateVectorStore; exports.YoutubeTranscriptReader = YoutubeTranscriptReader;
//# sourceMappingURL=chunk-I3M3DJ2E.cjs.map