@tailor-platform/sdk 0.0.1 → 0.8.1

package/dist/types-DWQxkbYl.d.mts

@@ -0,0 +1,1389 @@
+/// <reference path="./plugin-generated.d.ts" />
+
+import * as zod0 from "zod";
+import { z } from "zod";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import * as type_fest0 from "type-fest";
+import { IsAny, NonEmptyObject } from "type-fest";
+import * as zod_v4_core0 from "zod/v4/core";
+
+//#region src/configure/types/helpers.d.ts
+type Prettify<T> = { [K in keyof T as string extends K ? never : K]: T[K] } & {};
+type DeepWritable<T> = T extends Date | RegExp | Function ? T : T extends object ? { -readonly [P in keyof T]: DeepWritable<T[P]> } & {} : T;
+type output<T> = T extends {
+  _output: infer U;
+} ? DeepWritable<U> : never;
+type NullableToOptional<T> = { [K in keyof T as null extends T[K] ? never : K]: T[K] } & { [K in keyof T as null extends T[K] ? K : never]?: T[K] };
+type InferFieldsOutput<F extends Record<string, {
+  _output: any;
+  [key: string]: any;
+}>> = DeepWritable<Prettify<NullableToOptional<{ [K in keyof F]: output<F[K]> }>>>;
+//#endregion
+//#region src/parser/service/resolver/schema.d.ts
+declare const QueryTypeSchema: z.ZodUnion<readonly [z.ZodLiteral<"query">, z.ZodLiteral<"mutation">]>;
+declare const TailorFieldSchema: z.ZodObject<{
+  type: z.ZodEnum<{
+    string: "string";
+    boolean: "boolean";
+    uuid: "uuid";
+    integer: "integer";
+    float: "float";
+    enum: "enum";
+    date: "date";
+    datetime: "datetime";
+    time: "time";
+    nested: "nested";
+  }>;
+  metadata: z.ZodObject<{
+    required: z.ZodOptional<z.ZodBoolean>;
+    array: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    allowedValues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      value: z.ZodString;
+      description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    hooks: z.ZodOptional<z.ZodObject<{
+      create: z.ZodOptional<z.ZodCustom<Function, Function>>;
+      update: z.ZodOptional<z.ZodCustom<Function, Function>>;
+    }, z.core.$strip>>;
+    typeName: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  fields: z.ZodRecord<z.ZodString, z.ZodObject< /*elided*/any, z.core.$strip>>;
+}, z.core.$strip>;
+declare const ResolverSchema: z.ZodObject<{
+  operation: z.ZodUnion<readonly [z.ZodLiteral<"query">, z.ZodLiteral<"mutation">]>;
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodEnum<{
+      string: "string";
+      boolean: "boolean";
+      uuid: "uuid";
+      integer: "integer";
+      float: "float";
+      enum: "enum";
+      date: "date";
+      datetime: "datetime";
+      time: "time";
+      nested: "nested";
+    }>;
+    metadata: z.ZodObject<{
+      required: z.ZodOptional<z.ZodBoolean>;
+      array: z.ZodOptional<z.ZodBoolean>;
+      description: z.ZodOptional<z.ZodString>;
+      allowedValues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>>;
+      hooks: z.ZodOptional<z.ZodObject<{
+        create: z.ZodOptional<z.ZodCustom<Function, Function>>;
+        update: z.ZodOptional<z.ZodCustom<Function, Function>>;
+      }, z.core.$strip>>;
+      typeName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    fields: z.ZodRecord<z.ZodString, z.ZodObject< /*elided*/any, z.core.$strip>>;
+  }, z.core.$strip>>>;
+  body: z.ZodCustom<Function, Function>;
+  output: z.ZodObject<{
+    type: z.ZodEnum<{
+      string: "string";
+      boolean: "boolean";
+      uuid: "uuid";
+      integer: "integer";
+      float: "float";
+      enum: "enum";
+      date: "date";
+      datetime: "datetime";
+      time: "time";
+      nested: "nested";
+    }>;
+    metadata: z.ZodObject<{
+      required: z.ZodOptional<z.ZodBoolean>;
+      array: z.ZodOptional<z.ZodBoolean>;
+      description: z.ZodOptional<z.ZodString>;
+      allowedValues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>>;
+      hooks: z.ZodOptional<z.ZodObject<{
+        create: z.ZodOptional<z.ZodCustom<Function, Function>>;
+        update: z.ZodOptional<z.ZodCustom<Function, Function>>;
+      }, z.core.$strip>>;
+      typeName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    fields: z.ZodRecord<z.ZodString, z.ZodObject< /*elided*/any, z.core.$strip>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+//#endregion
+//#region src/parser/service/resolver/types.d.ts
+type TailorFieldInput = z.input<typeof TailorFieldSchema>;
+type QueryType = z.output<typeof QueryTypeSchema>;
+type ResolverInput = z.input<typeof ResolverSchema>;
+type Resolver = z.output<typeof ResolverSchema>;
+//#endregion
+//#region src/configure/types/type.d.ts
+declare class TailorField<const Defined extends DefinedFieldMetadata = DefinedFieldMetadata, const Output = any, M extends FieldMetadata = FieldMetadata> implements TailorFieldInput {
+  readonly type: TailorFieldType;
+  readonly fields: Record<string, TailorField<any>>;
+  protected _metadata: M;
+  readonly _defined: Defined;
+  readonly _output: Output;
+  get metadata(): M;
+  protected constructor(type: TailorFieldType, options?: FieldOptions, fields?: Record<string, TailorField<any>>, values?: AllowedValues);
+  static create<const TType extends TailorFieldType, const TOptions extends FieldOptions>(type: TType, options?: TOptions, fields?: Record<string, TailorField<any>>, values?: AllowedValues): TailorField<{
+    type: TType;
+    array: TOptions extends {
+      array: true;
+    } ? true : false;
+  }, FieldOutput<TailorToTs[TType], TOptions>, FieldMetadata>;
+  description<CurrentDefined extends Defined>(this: CurrentDefined extends {
+    description: unknown;
+  } ? never : TailorField<CurrentDefined, Output>, description: string): TailorField<Prettify<CurrentDefined & {
+    description: true;
+  }>, Output>;
+  typeName<CurrentDefined extends Defined>(this: CurrentDefined extends {
+    typeName: unknown;
+  } ? never : CurrentDefined extends {
+    type: "enum" | "nested";
+  } ? TailorField<CurrentDefined, Output> : never, typeName: string): TailorField<Prettify<CurrentDefined & {
+    typeName: true;
+  }>, Output>;
+  validate<CurrentDefined extends Defined>(this: CurrentDefined extends {
+    validate: unknown;
+  } ? never : TailorField<CurrentDefined, Output>, ...validate: FieldValidateInput<Output>[]): TailorField<Prettify<CurrentDefined & {
+    validate: true;
+  }>, Output>;
+  /**
+   * Parse and validate a value against this field's validation rules
+   * Returns StandardSchema Result type with success or failure
+   */
+  parse(args: {
+    value: any;
+    data: any;
+    user: TailorUser;
+  }): StandardSchemaV1.Result<Output>;
+  /**
+   * Validate a single value (not an array element)
+   * Used internally for array element validation
+   * @private
+   */
+  private _validateValue;
+  /**
+   * Internal parse method that tracks field path for nested validation
+   * @private
+   */
+  private _parseInternal;
+}
+//#endregion
+//#region src/configure/types/user.d.ts
+declare global {
+  namespace TailorSDK {
+    interface AttributeMap {}
+    interface AttributeList {
+      __tuple?: [];
+    }
+  }
+}
+type InferredAttributeMap = keyof TailorSDK.AttributeMap extends never ? Record<string, string | string[] | boolean | boolean[] | undefined> : TailorSDK.AttributeMap;
+type InferredAttributeList = TailorSDK.AttributeList["__tuple"] extends [] ? string[] : TailorSDK.AttributeList["__tuple"];
+/** Represents a user in the Tailor platform. */
+type TailorUser = {
+  /**
+   * The ID of the user.
+   * For unauthenticated users, this will be a nil UUID.
+   */
+  id: string;
+  /**
+   * The type of the user.
+   * For unauthenticated users, this will be an empty string.
+   */
+  type: "user" | "machine_user" | "";
+  /** The ID of the workspace the user belongs to. */
+  workspaceId: string;
+  /**
+   * A map of the user's attributes.
+   * For unauthenticated users, this will be null.
+   */
+  attributes: InferredAttributeMap | null;
+  /** A list of the user's attributes.
+   * For unauthenticated users, this will be an empty array.
+   */
+  attributeList: InferredAttributeList;
+};
+/** Represents an unauthenticated user in the Tailor platform. */
+declare const unauthenticatedTailorUser: TailorUser;
+//#endregion
+//#region src/configure/types/validation.d.ts
+/**
+ * Validation function type
+ */
+type ValidateFn<O, D = unknown> = (args: {
+  value: O;
+  data: D;
+  user: TailorUser;
+}) => boolean;
+/**
+ * Validation configuration with custom error message
+ */
+type ValidateConfig<O, D = unknown> = [ValidateFn<O, D>, string];
+/**
+ * Field-level validation function
+ */
+type FieldValidateFn<O> = ValidateFn<O>;
+/**
+ * Field-level validation configuration
+ */
+type FieldValidateConfig<O> = ValidateConfig<O>;
+/**
+ * Input type for field validation - can be either a function or a tuple of [function, errorMessage]
+ */
+type FieldValidateInput<O> = FieldValidateFn<O> | FieldValidateConfig<O>;
+/**
+ * Base validators type for field collections
+ * @template F - Record of fields
+ * @template ExcludeKeys - Keys to exclude from validation (default: "id" for TailorDB)
+ */
+type ValidatorsBase<F extends Record<string, {
+  _defined: any;
+  _output: any;
+  [key: string]: any;
+}>, ExcludeKeys extends string = "id"> = NonEmptyObject<{ [K in Exclude<keyof F, ExcludeKeys> as F[K]["_defined"] extends {
+  validate: unknown;
+} ? never : K]?: ValidateFn<output<F[K]>, InferFieldsOutput<F>> | ValidateConfig<output<F[K]>, InferFieldsOutput<F>> | (ValidateFn<output<F[K]>, InferFieldsOutput<F>> | ValidateConfig<output<F[K]>, InferFieldsOutput<F>>)[] }>;
+/**
+ * Validators type (by default excludes "id" field for TailorDB compatibility)
+ * Can be used with both TailorField and TailorDBField
+ */
+type Validators<F extends Record<string, {
+  _defined: any;
+  _output: any;
+  [key: string]: any;
+}>> = ValidatorsBase<F, "id">;
+//#endregion
+//#region src/configure/types/types.d.ts
+type TailorFieldType = "uuid" | "string" | "boolean" | "integer" | "float" | "enum" | "date" | "datetime" | "time" | "nested";
+type TailorToTs = {
+  string: string;
+  integer: number;
+  float: number;
+  boolean: boolean;
+  uuid: string;
+  date: string;
+  datetime: string;
+  time: string;
+  enum: string;
+  object: Record<string, unknown>;
+  nested: Record<string, unknown>;
+} & Record<TailorFieldType, unknown>;
+interface Script {
+  expr: string;
+}
+interface EnumValue {
+  value: string;
+  description?: string;
+}
+interface FieldMetadata {
+  description?: string;
+  required?: boolean;
+  array?: boolean;
+  allowedValues?: AllowedValue[];
+  validate?: FieldValidateInput<any>[];
+  typeName?: string;
+}
+interface DefinedFieldMetadata {
+  type: TailorFieldType;
+  array: boolean;
+  description?: boolean;
+  validate?: boolean;
+  typeName?: boolean;
+}
+type FieldOptions = {
+  optional?: boolean;
+  array?: boolean;
+};
+type FieldOutput<T, O extends FieldOptions> = OptionalFieldOutput<ArrayFieldOutput<T, O>, O>;
+type OptionalFieldOutput<T, O extends FieldOptions> = O["optional"] extends true ? T | null : T;
+type ArrayFieldOutput<T, O extends FieldOptions> = [O] extends [{
+  array: true;
+}] ? T[] : T;
+//#endregion
+//#region src/configure/types/field.d.ts
+type AllowedValue = EnumValue;
+type AllowedValues = [string | EnumValue, ...(string | EnumValue)[]];
+type AllowedValuesOutput<V extends AllowedValues> = V[number] extends infer T ? T extends string ? T : T extends {
+  value: infer K;
+} ? K : never : never;
+//#endregion
+//#region src/configure/types/operator.d.ts
+interface OperatorValidateConfig {
+  script: Script;
+  errorMessage: string;
+}
+interface OperatorFieldHook {
+  create?: Script;
+  update?: Script;
+}
+interface OperatorFieldConfig {
+  type: string;
+  required?: boolean;
+  description?: string;
+  allowedValues?: EnumValue[];
+  array?: boolean;
+  index?: boolean;
+  unique?: boolean;
+  vector?: boolean;
+  foreignKey?: boolean;
+  foreignKeyType?: string;
+  foreignKeyField?: string;
+  validate?: OperatorValidateConfig[];
+  hooks?: OperatorFieldHook;
+  serial?: {
+    start: number;
+    maxValue?: number;
+    format?: string;
+  };
+  fields?: Record<string, OperatorFieldConfig>;
+}
+//#endregion
+//#region src/parser/service/auth/schema.d.ts
+declare const OIDCSchema: z.ZodObject<{
+  name: z.ZodString;
+  kind: z.ZodLiteral<"OIDC">;
+  clientID: z.ZodString;
+  clientSecret: z.ZodObject<{
+    VaultName: z.ZodString;
+    SecretKey: z.ZodString;
+  }, z.core.$strip>;
+  providerURL: z.ZodString;
+  issuerURL: z.ZodOptional<z.ZodString>;
+  usernameClaim: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const SAMLSchema: z.ZodObject<{
+  name: z.ZodString;
+  kind: z.ZodLiteral<"SAML">;
+  spCertBase64: z.ZodOptional<z.ZodObject<{
+    VaultName: z.ZodString;
+    SecretKey: z.ZodString;
+  }, z.core.$strip>>;
+  spKeyBase64: z.ZodOptional<z.ZodObject<{
+    VaultName: z.ZodString;
+    SecretKey: z.ZodString;
+  }, z.core.$strip>>;
+  metadataURL: z.ZodOptional<z.ZodString>;
+  rawMetadata: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const IDTokenSchema: z.ZodObject<{
+  name: z.ZodString;
+  kind: z.ZodLiteral<"IDToken">;
+  providerURL: z.ZodString;
+  issuerURL: z.ZodOptional<z.ZodString>;
+  clientID: z.ZodString;
+  usernameClaim: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const BuiltinIdPSchema: z.ZodObject<{
+  name: z.ZodString;
+  kind: z.ZodLiteral<"BuiltInIdP">;
+  namespace: z.ZodString;
+  clientName: z.ZodString;
+}, z.core.$strip>;
+declare const IdProviderSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  name: z.ZodString;
+  kind: z.ZodLiteral<"OIDC">;
+  clientID: z.ZodString;
+  clientSecret: z.ZodObject<{
+    VaultName: z.ZodString;
+    SecretKey: z.ZodString;
+  }, z.core.$strip>;
+  providerURL: z.ZodString;
+  issuerURL: z.ZodOptional<z.ZodString>;
+  usernameClaim: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  name: z.ZodString;
+  kind: z.ZodLiteral<"SAML">;
+  spCertBase64: z.ZodOptional<z.ZodObject<{
+    VaultName: z.ZodString;
+    SecretKey: z.ZodString;
+  }, z.core.$strip>>;
+  spKeyBase64: z.ZodOptional<z.ZodObject<{
+    VaultName: z.ZodString;
+    SecretKey: z.ZodString;
+  }, z.core.$strip>>;
+  metadataURL: z.ZodOptional<z.ZodString>;
+  rawMetadata: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  name: z.ZodString;
+  kind: z.ZodLiteral<"IDToken">;
+  providerURL: z.ZodString;
+  issuerURL: z.ZodOptional<z.ZodString>;
+  clientID: z.ZodString;
+  usernameClaim: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  name: z.ZodString;
+  kind: z.ZodLiteral<"BuiltInIdP">;
+  namespace: z.ZodString;
+  clientName: z.ZodString;
+}, z.core.$strip>], "kind">;
+declare const OAuth2ClientGrantTypeSchema: z.ZodUnion<readonly [z.ZodLiteral<"authorization_code">, z.ZodLiteral<"refresh_token">]>;
+declare const OAuth2ClientSchema: z.ZodObject<{
+  description: z.ZodOptional<z.ZodString>;
+  grantTypes: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"authorization_code">, z.ZodLiteral<"refresh_token">]>>>;
+  redirectURIs: z.ZodArray<z.ZodUnion<readonly [z.ZodTemplateLiteral<`https://${string}`>, z.ZodTemplateLiteral<`http://${string}`>, z.ZodTemplateLiteral<`${string}:url`>, z.ZodTemplateLiteral<`${string}:url/${string}`>]>>;
+  clientType: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"confidential">, z.ZodLiteral<"public">, z.ZodLiteral<"browser">]>>;
+}, z.core.$strip>;
+declare const SCIMAuthorizationSchema: z.ZodObject<{
+  type: z.ZodUnion<readonly [z.ZodLiteral<"oauth2">, z.ZodLiteral<"bearer">]>;
+  bearerSecret: z.ZodOptional<z.ZodObject<{
+    VaultName: z.ZodString;
+    SecretKey: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const SCIMAttributeTypeSchema: z.ZodUnion<readonly [z.ZodLiteral<"string">, z.ZodLiteral<"number">, z.ZodLiteral<"boolean">, z.ZodLiteral<"datetime">, z.ZodLiteral<"complex">]>;
+declare const SCIMAttributeSchema: z.ZodObject<{
+  type: z.ZodUnion<readonly [z.ZodLiteral<"string">, z.ZodLiteral<"number">, z.ZodLiteral<"boolean">, z.ZodLiteral<"datetime">, z.ZodLiteral<"complex">]>;
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  mutability: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"readOnly">, z.ZodLiteral<"readWrite">, z.ZodLiteral<"writeOnly">]>>;
+  required: z.ZodOptional<z.ZodBoolean>;
+  multiValued: z.ZodOptional<z.ZodBoolean>;
+  uniqueness: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodLiteral<"server">, z.ZodLiteral<"global">]>>;
+  canonicalValues: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+  subAttributes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject< /*elided*/any, z.core.$strip>>>>;
+}, z.core.$strip>;
+declare const SCIMAttributeMappingSchema: z.ZodObject<{
+  tailorDBField: z.ZodString;
+  scimPath: z.ZodString;
+}, z.core.$strip>;
+declare const SCIMResourceSchema: z.ZodObject<{
+  name: z.ZodString;
+  tailorDBNamespace: z.ZodString;
+  tailorDBType: z.ZodString;
+  coreSchema: z.ZodObject<{
+    name: z.ZodString;
+    attributes: z.ZodArray<z.ZodObject<{
+      type: z.ZodUnion<readonly [z.ZodLiteral<"string">, z.ZodLiteral<"number">, z.ZodLiteral<"boolean">, z.ZodLiteral<"datetime">, z.ZodLiteral<"complex">]>;
+      name: z.ZodString;
+      description: z.ZodOptional<z.ZodString>;
+      mutability: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"readOnly">, z.ZodLiteral<"readWrite">, z.ZodLiteral<"writeOnly">]>>;
+      required: z.ZodOptional<z.ZodBoolean>;
+      multiValued: z.ZodOptional<z.ZodBoolean>;
+      uniqueness: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodLiteral<"server">, z.ZodLiteral<"global">]>>;
+      canonicalValues: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+      subAttributes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject< /*elided*/any, z.core.$strip>>>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  attributeMapping: z.ZodArray<z.ZodObject<{
+    tailorDBField: z.ZodString;
+    scimPath: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const SCIMSchema: z.ZodObject<{
+  machineUserName: z.ZodString;
+  authorization: z.ZodObject<{
+    type: z.ZodUnion<readonly [z.ZodLiteral<"oauth2">, z.ZodLiteral<"bearer">]>;
+    bearerSecret: z.ZodOptional<z.ZodObject<{
+      VaultName: z.ZodString;
+      SecretKey: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  resources: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    tailorDBNamespace: z.ZodString;
+    tailorDBType: z.ZodString;
+    coreSchema: z.ZodObject<{
+      name: z.ZodString;
+      attributes: z.ZodArray<z.ZodObject<{
+        type: z.ZodUnion<readonly [z.ZodLiteral<"string">, z.ZodLiteral<"number">, z.ZodLiteral<"boolean">, z.ZodLiteral<"datetime">, z.ZodLiteral<"complex">]>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        mutability: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"readOnly">, z.ZodLiteral<"readWrite">, z.ZodLiteral<"writeOnly">]>>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        multiValued: z.ZodOptional<z.ZodBoolean>;
+        uniqueness: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodLiteral<"server">, z.ZodLiteral<"global">]>>;
+        canonicalValues: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        subAttributes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject< /*elided*/any, z.core.$strip>>>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    attributeMapping: z.ZodArray<z.ZodObject<{
+      tailorDBField: z.ZodString;
+      scimPath: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const TenantProviderSchema: z.ZodObject<{
+  namespace: z.ZodString;
+  type: z.ZodString;
+  signatureField: z.ZodString;
+}, z.core.$strip>;
+//#endregion
+//#region src/parser/service/auth/types.d.ts
+type OIDC = z.output<typeof OIDCSchema>;
+type SAML = z.output<typeof SAMLSchema>;
+type IDToken = z.output<typeof IDTokenSchema>;
+type BuiltinIdP = z.output<typeof BuiltinIdPSchema>;
+type IdProviderConfig = z.output<typeof IdProviderSchema>;
+type OAuth2ClientGrantType = z.output<typeof OAuth2ClientGrantTypeSchema>;
+type OAuth2Client = z.output<typeof OAuth2ClientSchema>;
+type SCIMAuthorization = z.output<typeof SCIMAuthorizationSchema>;
+type SCIMAttributeType = z.output<typeof SCIMAttributeTypeSchema>;
+type SCIMAttribute = z.output<typeof SCIMAttributeSchema>;
+type SCIMAttributeMapping = z.output<typeof SCIMAttributeMappingSchema>;
+type SCIMResource = z.output<typeof SCIMResourceSchema>;
+type SCIMConfig = z.output<typeof SCIMSchema>;
+type TenantProviderConfig = z.output<typeof TenantProviderSchema>;
+type ValueOperand = string | boolean | string[] | boolean[];
+type AuthAttributeValue = ValueOperand | null | undefined;
+type UserFieldKeys<User extends TailorDBInstance> = keyof output<User> & string;
+type FieldDefined<User extends TailorDBInstance, Key extends UserFieldKeys<User>> = User["fields"][Key] extends {
+  _defined: infer Defined;
+} ? Defined : never;
+type FieldOutput$1<User extends TailorDBInstance, Key extends UserFieldKeys<User>> = output<User>[Key];
+type FieldIsRequired<User extends TailorDBInstance, Key extends UserFieldKeys<User>> = undefined extends FieldOutput$1<User, Key> ? false : true;
+type FieldIsOfType<User extends TailorDBInstance, Key extends UserFieldKeys<User>, Type extends string> = FieldDefined<User, Key> extends {
+  type: Type;
+} ? true : false;
+type FieldIsArray<User extends TailorDBInstance, Key extends UserFieldKeys<User>> = FieldDefined<User, Key> extends {
+  array: true;
+} ? true : false;
+type FieldIsUnique<User extends TailorDBInstance, Key extends UserFieldKeys<User>> = FieldDefined<User, Key> extends {
+  unique: true;
+} ? true : false;
+type FieldSupportsValueOperand<User extends TailorDBInstance, Key extends UserFieldKeys<User>> = FieldOutput$1<User, Key> extends ValueOperand | null | undefined ? true : false;
+type UsernameFieldKey<User extends TailorDBInstance> = IsAny<User> extends true ? string : { [K in UserFieldKeys<User>]: FieldIsRequired<User, K> extends true ? FieldIsOfType<User, K, "string"> extends true ? FieldIsArray<User, K> extends true ? never : FieldIsUnique<User, K> extends true ? K : never : never : never }[UserFieldKeys<User>];
+type UserAttributeKey<User extends TailorDBInstance> = { [K in UserFieldKeys<User>]: K extends "id" ? never : FieldSupportsValueOperand<User, K> extends true ? FieldIsOfType<User, K, "datetime" | "date" | "time"> extends true ? never : K : never }[UserFieldKeys<User>];
+type UserAttributeListKey<User extends TailorDBInstance> = { [K in UserFieldKeys<User>]: K extends "id" ? never : FieldIsOfType<User, K, "uuid"> extends true ? FieldIsArray<User, K> extends true ? never : K : never }[UserFieldKeys<User>];
+type UserAttributeMap<User extends TailorDBInstance> = { [K in UserAttributeKey<User>]?: true };
+type DisallowExtraKeys<T, Allowed extends PropertyKey> = T & { [K in Exclude<keyof T, Allowed>]: never };
+type AttributeListValue<User extends TailorDBInstance, Key extends UserAttributeListKey<User>> = Key extends keyof output<User> ? output<User>[Key] : never;
+type AttributeListToTuple<User extends TailorDBInstance, AttributeList extends readonly UserAttributeListKey<User>[]> = { [Index in keyof AttributeList]: AttributeList[Index] extends UserAttributeListKey<User> ? AttributeListValue<User, AttributeList[Index]> : never };
+type AttributeMapSelectedKeys<User extends TailorDBInstance, AttributeMap extends UserAttributeMap<User>> = Extract<{ [K in keyof AttributeMap]-?: undefined extends AttributeMap[K] ? never : K }[keyof AttributeMap], UserAttributeKey<User>>;
+type UserProfile<User extends TailorDBInstance, AttributeMap extends UserAttributeMap<User>, AttributeList extends UserAttributeListKey<User>[]> = {
+  type: User;
+  usernameField: UsernameFieldKey<User>;
+  attributes?: DisallowExtraKeys<AttributeMap, UserAttributeKey<User>>;
+  attributeList?: AttributeList;
+};
+type MachineUser<User extends TailorDBInstance, AttributeMap extends UserAttributeMap<User> = UserAttributeMap<User>, AttributeList extends UserAttributeListKey<User>[] = []> = IsAny<User> extends true ? {
+  attributes: Record<string, AuthAttributeValue>;
+  attributeList?: string[];
+} : (AttributeMapSelectedKeys<User, AttributeMap> extends never ? {
+  attributes?: never;
+} : {
+  attributes: { [K in AttributeMapSelectedKeys<User, AttributeMap>]: K extends keyof output<User> ? output<User>[K] : never } & { [K in Exclude<keyof output<User>, AttributeMapSelectedKeys<User, AttributeMap>>]?: never };
+}) & ([] extends AttributeList ? {
+  attributeList?: never;
+} : {
+  attributeList: AttributeListToTuple<User, AttributeList>;
+});
+type AuthServiceInput<User extends TailorDBInstance, AttributeMap extends UserAttributeMap<User>, AttributeList extends UserAttributeListKey<User>[], MachineUserNames extends string> = {
+  userProfile?: UserProfile<User, AttributeMap, AttributeList>;
+  machineUsers?: Record<MachineUserNames, MachineUser<User, AttributeMap, AttributeList>>;
+  oauth2Clients?: Record<string, OAuth2Client>;
+  idProvider?: IdProviderConfig;
+  scim?: SCIMConfig;
+  tenantProvider?: TenantProviderConfig;
+};
+//#endregion
+//#region src/configure/services/auth/index.d.ts
+declare const authDefinitionBrand: unique symbol;
+type AuthDefinitionBrand = {
+  readonly [authDefinitionBrand]: true;
+};
+declare function defineAuth<const Name extends string, const User extends TailorDBInstance, const AttributeMap extends UserAttributeMap<User>, const AttributeList extends UserAttributeListKey<User>[], const MachineUserNames extends string>(name: Name, config: AuthServiceInput<User, AttributeMap, AttributeList, MachineUserNames>): {
+  readonly name: Name;
+  readonly invoker: <M extends MachineUserNames>(machineUser: M) => {
+    readonly authName: Name;
+    readonly machineUser: M;
+  };
+  readonly userProfile?: {
+    type: User;
+    usernameField: UsernameFieldKey<User>;
+    attributes?: (AttributeMap & { [K in Exclude<keyof AttributeMap, UserAttributeKey<User>>]: never }) | undefined;
+    attributeList?: AttributeList | undefined;
+  } | undefined;
+  readonly machineUsers?: Record<MachineUserNames, type_fest0.IsAny<User> extends true ? {
+    attributes: Record<string, AuthAttributeValue>;
+    attributeList?: string[];
+  } : (Extract<{ [K_1 in keyof AttributeMap]-?: undefined extends AttributeMap[K_1] ? never : K_1 }[keyof AttributeMap], UserAttributeKey<User>> extends never ? {
+    attributes?: never;
+  } : {
+    attributes: { [K_2 in Extract<{ [K_1 in keyof AttributeMap]-?: undefined extends AttributeMap[K_1] ? never : K_1 }[keyof AttributeMap], UserAttributeKey<User>>]: K_2 extends keyof output<User> ? output<User>[K_2] : never } & { [K_3 in Exclude<keyof output<User>, Extract<{ [K_1 in keyof AttributeMap]-?: undefined extends AttributeMap[K_1] ? never : K_1 }[keyof AttributeMap], UserAttributeKey<User>>>]?: undefined };
+  }) & ([] extends AttributeList ? {
+    attributeList?: never;
+  } : {
+    attributeList: { [Index in keyof AttributeList]: AttributeList[Index] extends UserAttributeListKey<User> ? AttributeList[Index] extends infer T ? T extends AttributeList[Index] ? T extends keyof output<User> ? output<User>[T] : never : never : never : never };
+  })> | undefined;
+  readonly oauth2Clients?: Record<string, OAuth2Client>;
+  readonly idProvider?: IdProviderConfig;
+  readonly scim?: SCIMConfig;
+  readonly tenantProvider?: TenantProviderConfig;
+} & AuthDefinitionBrand;
+type AuthConfig = ReturnType<typeof defineAuth<string, any, any, any, string>>;
+//#endregion
+//#region src/configure/services/tailordb/permission.d.ts
+interface Permissions {
+  record?: StandardTailorTypePermission;
+  gql?: StandardTailorTypeGqlPermission;
+}
+type TailorTypePermission<User extends object = InferredAttributeMap, Type extends object = object> = {
+  create: readonly ActionPermission<"record", User, Type, false>[];
+  read: readonly ActionPermission<"record", User, Type, false>[];
+  update: readonly ActionPermission<"record", User, Type, true>[];
+  delete: readonly ActionPermission<"record", User, Type, false>[];
+};
+type StandardTailorTypePermission = {
+  create: readonly StandardActionPermission<"record", false>[];
+  read: readonly StandardActionPermission<"record", false>[];
+  update: readonly StandardActionPermission<"record", true>[];
+  delete: readonly StandardActionPermission<"record", false>[];
+};
+type ActionPermission<Level extends "record" | "gql" = "record" | "gql", User extends object = InferredAttributeMap, Type extends object = object, Update extends boolean = boolean> = {
+  conditions: PermissionCondition<Level, User, Update, Type> | readonly PermissionCondition<Level, User, Update, Type>[];
+  description?: string | undefined;
+  permit?: boolean;
+} | readonly [...PermissionCondition<Level, User, Update, Type>, ...([] | [boolean])] | readonly [...PermissionCondition<Level, User, Update, Type>[], ...([] | [boolean])];
+type StandardActionPermission<Level extends "record" | "gql" = "record" | "gql", Update extends boolean = boolean> = {
+  conditions: readonly StandardPermissionCondition<Level, Update>[];
+  description?: string;
+  permit: "allow" | "deny";
+};
+type TailorTypeGqlPermission<User extends object = InferredAttributeMap, Type extends object = object> = readonly GqlPermissionPolicy<User, Type>[];
+type StandardTailorTypeGqlPermission = readonly StandardGqlPermissionPolicy[];
+type GqlPermissionPolicy<User extends object = InferredAttributeMap, Type extends object = object> = {
+  conditions: readonly PermissionCondition<"gql", User, boolean, Type>[];
+  actions: "all" | readonly GqlPermissionAction[];
+  permit?: boolean;
+  description?: string;
+};
+type StandardGqlPermissionPolicy = {
+  conditions: readonly StandardPermissionCondition<"gql">[];
+  actions: readonly ["all"] | readonly GqlPermissionAction[];
+  permit: "allow" | "deny";
+  description?: string;
+};
+type GqlPermissionAction = "read" | "create" | "update" | "delete" | "aggregate" | "bulkUpsert";
+type PermissionCondition<Level extends "record" | "gql" = "record" | "gql", User extends object = InferredAttributeMap, Update extends boolean = boolean, Type extends object = object> = readonly [PermissionOperand<Level, User, Type, Update>, PermissionOperator, PermissionOperand<Level, User, Type, Update>];
+type StandardPermissionCondition<Level extends "record" | "gql" = "record" | "gql", Update extends boolean = boolean> = readonly [PermissionOperand<Level, Record<string, unknown>, Record<string, unknown>, Update>, StandardPermissionOperator, PermissionOperand<Level, Record<string, unknown>, Record<string, unknown>, Update>];
+type UserOperand<User extends object = InferredAttributeMap> = {
+  user: { [K in keyof User]: User[K] extends string | string[] | boolean | boolean[] ? K : never }[keyof User] | "id" | "_loggedIn";
+};
+type RecordOperand<Type extends object, Update extends boolean = false> = Update extends true ? {
+  oldRecord: (keyof Type & string) | "id";
+} | {
+  newRecord: (keyof Type & string) | "id";
+} : {
+  record: (keyof Type & string) | "id";
+};
+type PermissionOperand<Level extends "record" | "gql" = "record" | "gql", User extends object = InferredAttributeMap, Type extends object = object, Update extends boolean = boolean> = UserOperand<User> | ValueOperand | (Level extends "record" ? RecordOperand<Type, Update> : never);
+type PermissionOperator = "=" | "!=" | "in" | "not in";
+declare const operatorMap: {
+  readonly "=": "eq";
+  readonly "!=": "ne";
+  readonly in: "in";
+  readonly "not in": "nin";
+};
+type StandardPermissionOperator = (typeof operatorMap)[keyof typeof operatorMap];
+//#endregion
+//#region src/configure/services/tailordb/operator-types.d.ts
+interface TailorDBTypeConfig {
+  name: string;
+  schema: {
+    description?: string;
+    extends: boolean;
+    fields: Record<string, OperatorFieldConfig>;
+    settings?: {
+      pluralForm?: string;
+      aggregation?: boolean;
+      bulkUpsert?: boolean;
+    };
+    permissions: Permissions;
+    files: Record<string, string>;
+    indexes?: Record<string, {
+      fields: string[];
+      unique?: boolean;
+    }>;
+  };
+}
+//#endregion
+//#region src/configure/services/tailordb/types.d.ts
+type SerialConfig<T extends "string" | "integer" = "string" | "integer"> = Prettify<{
+  start: number;
+  maxValue?: number;
+} & (T extends "string" ? {
+  format?: string;
+} : object)>;
+interface DBFieldMetadata extends FieldMetadata {
+  index?: boolean;
+  unique?: boolean;
+  vector?: boolean;
+  foreignKey?: boolean;
+  foreignKeyType?: string;
+  foreignKeyField?: string;
+  hooks?: Hook<any, any>;
+  serial?: SerialConfig;
+  relation?: boolean;
+}
+interface DefinedDBFieldMetadata extends DefinedFieldMetadata {
+  index?: boolean;
+  unique?: boolean;
+  vector?: boolean;
+  foreignKey?: boolean;
+  foreignKeyType?: boolean;
+  validate?: boolean;
+  hooks?: {
+    create: boolean;
+    update: boolean;
+  };
+  serial?: boolean;
+  relation?: boolean;
+}
+type ExcludeNestedDBFields<T extends Record<string, TailorDBField<any, any>>> = { [K in keyof T]: T[K] extends TailorDBField<{
+  type: "nested";
+  array: boolean;
+}, any> ? never : T[K] };
+type HookFn<TValue, TData, TReturn> = (args: {
+  value: TValue;
+  data: TData extends Record<string, unknown> ? { readonly [K in keyof TData]?: TData[K] | null | undefined } : unknown;
+  user: TailorUser;
+}) => TReturn;
+type Hook<TData, TReturn> = {
+  create?: HookFn<TReturn | null, TData, TReturn>;
+  update?: HookFn<TReturn | null, TData, TReturn>;
+};
+type Hooks<F extends Record<string, TailorDBField<any, any>>, TData = { [K in keyof F]: output<F[K]> }> = NonEmptyObject<{ [K in Exclude<keyof F, "id"> as F[K]["_defined"] extends {
+  hooks: unknown;
+} ? never : F[K]["_defined"] extends {
+  type: "nested";
+} ? never : K]?: Hook<TData, output<F[K]>> }>;
+type TailorDBServiceConfig = {
+  files: string[];
+  ignores?: string[];
+};
+type TailorDBServiceInput = {
+  [namespace: string]: TailorDBServiceConfig;
+};
+type IndexDef<T extends {
+  fields: Record<PropertyKey, unknown>;
+}> = {
+  fields: [keyof T["fields"], keyof T["fields"], ...(keyof T["fields"])[]];
+  unique?: boolean;
+  name?: string;
+};
+interface TypeFeatures {
+  pluralForm?: string;
+  aggregation?: true;
+  bulkUpsert?: true;
+}
+//#endregion
+//#region src/configure/services/tailordb/schema.d.ts
+type RelationType = "oneToOne" | "1-1" | "manyToOne" | "n-1" | "N-1" | "keyOnly";
+interface RelationConfig<S extends RelationType, T extends TailorDBType> {
+  type: S;
+  toward: {
+    type: T;
+    as?: string;
+    key?: keyof T["fields"] & string;
+  };
+  backward?: string;
+}
+type RelationSelfConfig = {
+  type: "oneToOne" | "1-1" | "manyToOne" | "n-1" | "N-1" | "keyOnly";
+  toward: {
+    type: "self";
+    as?: string;
+    key?: string;
+  };
+  backward?: string;
+};
+interface ReferenceConfig<T extends TailorDBType<any, any>> {
+  type: TailorDBType<any, any>;
+  key: keyof T["fields"] & string;
+  nameMap: [string | undefined, string];
+}
+declare class TailorDBField<const Defined extends DefinedDBFieldMetadata, const Output> extends TailorField<Defined, Output, DBFieldMetadata> {
+  private _ref;
+  private _pendingSelfRelation;
+  get reference(): Readonly<ReferenceConfig<TailorDBType>> | undefined;
+  get metadata(): {
+    index?: boolean;
+    unique?: boolean;
+    vector?: boolean;
+    foreignKey?: boolean;
+    foreignKeyType?: string;
+    foreignKeyField?: string;
+    hooks?: Hook<any, any>;
+    serial?: SerialConfig;
+    relation?: boolean;
+    description?: string;
+    required?: boolean;
+    array?: boolean;
+    allowedValues?: AllowedValue[];
+    validate?: FieldValidateInput<any>[];
+    typeName?: string;
+  };
+  get config(): OperatorFieldConfig;
+  private constructor();
+  static create<const T extends TailorFieldType, const TOptions extends FieldOptions>(type: T, options?: TOptions, fields?: Record<string, TailorDBField<any, any>>, values?: AllowedValues): TailorDBField<{
+    type: T;
+    array: TOptions extends {
+      array: true;
+    } ? true : false;
+  }, FieldOutput<TailorToTs[T], TOptions>>;
+  description<CurrentDefined extends Defined>(this: CurrentDefined extends {
+    description: unknown;
+  } ? never : TailorField<CurrentDefined, Output>, description: string): TailorDBField<Prettify<CurrentDefined & {
+    description: true;
+  }>, Output>;
+  relation<S extends RelationType, T extends TailorDBType<any, any>, CurrentDefined extends Defined>(this: CurrentDefined extends {
+    relation: unknown;
+  } ? never : TailorDBField<CurrentDefined, Output>, config: RelationConfig<S, T>): TailorDBField<S extends "oneToOne" | "1-1" ? Prettify<CurrentDefined & {
+    unique: true;
+    index: true;
+    relation: true;
+  }> : Prettify<CurrentDefined & {
+    index: true;
+    relation: true;
+  }>, Output>;
+  relation<S extends RelationSelfConfig, CurrentDefined extends Defined>(this: CurrentDefined extends {
+    relation: unknown;
+  } ? never : TailorDBField<CurrentDefined, Output>, config: S): TailorDBField<S["type"] extends "oneToOne" | "1-1" ? Prettify<CurrentDefined & {
+    unique: true;
+    index: true;
+    relation: true;
+  }> : Prettify<CurrentDefined & {
+    index: true;
+    relation: true;
+  }>, Output>;
+  index<CurrentDefined extends Defined>(this: CurrentDefined extends {
+    index: unknown;
+  } ? never : TailorDBField<CurrentDefined, Output>): TailorDBField<Prettify<CurrentDefined & {
+    index: true;
+  }>, Output>;
+  unique<CurrentDefined extends Defined>(this: CurrentDefined extends {
+    unique: unknown;
+  } ? never : TailorDBField<CurrentDefined, Output>): TailorDBField<Prettify<CurrentDefined & {
+    unique: true;
+    index: true;
+  }>, Output>;
+  vector<CurrentDefined extends Defined>(this: CurrentDefined extends {
+    vector: unknown;
+  } ? never : CurrentDefined extends {
+    type: "string";
+    array: false;
+  } ? TailorDBField<CurrentDefined, Output> : never): TailorDBField<Prettify<CurrentDefined & {
+    vector: true;
+  }>, Output>;
+  hooks<CurrentDefined extends Defined, const H extends Hook<unknown, Output>>(this: CurrentDefined extends {
+    hooks: unknown;
+  } ? never : CurrentDefined extends {
+    type: "nested";
+  } ? never : TailorDBField<CurrentDefined, Output>, hooks: H): TailorDBField<Prettify<CurrentDefined & {
+    hooks?: {
+      create: H extends {
+        create: unknown;
+      } ? true : false;
+      update: H extends {
+        update: unknown;
+      } ? true : false;
+    };
+    serial: false;
+  }>, Output>;
+  validate<CurrentDefined extends Defined>(this: CurrentDefined extends {
+    validate: unknown;
+  } ? never : TailorDBField<CurrentDefined, Output>, ...validate: FieldValidateInput<Output>[]): TailorDBField<Prettify<CurrentDefined & {
+    validate: true;
+  }>, Output>;
+  serial<CurrentDefined extends Defined>(this: CurrentDefined extends {
+    serial: unknown;
+  } ? never : Output extends null ? never : CurrentDefined extends {
+    type: "integer" | "string";
+    array: false;
+  } ? TailorDBField<CurrentDefined, Output> : never, config: SerialConfig<CurrentDefined["type"] & ("integer" | "string")>): TailorDBField<Prettify<CurrentDefined & {
+    serial: true;
+    hooks: {
+      create: false;
+      update: false;
+    };
+  }>, Output>;
+  /**
+   * Clone the field with optional overrides for field options
+   * @param options - Optional field options to override
+   * @returns A new TailorDBField instance with the same configuration
+   */
+  clone<const NewOpt extends FieldOptions>(options?: NewOpt): TailorDBField<Prettify<Omit<Defined, "array"> & {
+    array: NewOpt extends {
+      array: true;
+    } ? true : Defined["array"];
+  }>, FieldOutput<TailorToTs[Defined["type"]], NewOpt>>;
+}
+declare function uuid<const Opt extends FieldOptions>(options?: Opt): TailorDBField<{
+  type: "uuid";
+  array: Opt extends {
+    array: true;
+  } ? true : false;
+}, Opt["optional"] extends true ? ArrayFieldOutput<string, Opt> | null : ArrayFieldOutput<string, Opt>>;
+declare function string<const Opt extends FieldOptions>(options?: Opt): TailorDBField<{
+  type: "string";
+  array: Opt extends {
+    array: true;
+  } ? true : false;
+}, Opt["optional"] extends true ? ArrayFieldOutput<string, Opt> | null : ArrayFieldOutput<string, Opt>>;
+declare function bool<const Opt extends FieldOptions>(options?: Opt): TailorDBField<{
+  type: "boolean";
+  array: Opt extends {
+    array: true;
+  } ? true : false;
+}, Opt["optional"] extends true ? ArrayFieldOutput<boolean, Opt> | null : ArrayFieldOutput<boolean, Opt>>;
+declare function int<const Opt extends FieldOptions>(options?: Opt): TailorDBField<{
+  type: "integer";
+  array: Opt extends {
+    array: true;
+  } ? true : false;
+}, Opt["optional"] extends true ? ArrayFieldOutput<number, Opt> | null : ArrayFieldOutput<number, Opt>>;
+declare function float<const Opt extends FieldOptions>(options?: Opt): TailorDBField<{
+  type: "float";
+  array: Opt extends {
+    array: true;
+  } ? true : false;
+}, Opt["optional"] extends true ? ArrayFieldOutput<number, Opt> | null : ArrayFieldOutput<number, Opt>>;
+declare function date<const Opt extends FieldOptions>(options?: Opt): TailorDBField<{
+  type: "date";
+  array: Opt extends {
+    array: true;
+  } ? true : false;
+}, Opt["optional"] extends true ? ArrayFieldOutput<string, Opt> | null : ArrayFieldOutput<string, Opt>>;
+declare function datetime<const Opt extends FieldOptions>(options?: Opt): TailorDBField<{
+  type: "datetime";
+  array: Opt extends {
+    array: true;
+  } ? true : false;
+}, Opt["optional"] extends true ? ArrayFieldOutput<string, Opt> | null : ArrayFieldOutput<string, Opt>>;
+declare function time<const Opt extends FieldOptions>(options?: Opt): TailorDBField<{
+  type: "time";
+  array: Opt extends {
+    array: true;
+  } ? true : false;
+}, Opt["optional"] extends true ? ArrayFieldOutput<string, Opt> | null : ArrayFieldOutput<string, Opt>>;
+declare function _enum<const V extends AllowedValues>(...values: V): TailorDBField<{
+  type: "enum";
+  array: false;
+}, FieldOutput<AllowedValuesOutput<V>, {
+  optional: false;
+  array: false;
+}>>;
+declare function _enum<const V extends AllowedValues, const Opt extends FieldOptions>(...args: [...V, Opt]): TailorDBField<{
+  type: "enum";
+  array: Opt extends {
+    array: true;
+  } ? true : false;
+}, FieldOutput<AllowedValuesOutput<V>, Opt>>;
+declare function object<const F extends Record<string, TailorDBField<any, any>> & ExcludeNestedDBFields<F>, const Opt extends FieldOptions>(fields: F, options?: Opt): TailorDBField<{
+  type: "nested";
+  array: Opt extends {
+    array: true;
+  } ? true : false;
+}, FieldOutput<InferFieldsOutput<F>, Opt>>;
+declare class TailorDBType<const Fields extends Record<string, TailorDBField<any, any>> = any, User extends object = InferredAttributeMap> {
+  readonly name: string;
+  readonly fields: Fields;
+  readonly _output: InferFieldsOutput<Fields>;
+  _description?: string;
+  readonly referenced: Record<string, [TailorDBType<any, any>, string]>;
+  private _settings;
+  private _indexes;
+  private _permissions;
+  private _files;
+  constructor(name: string, fields: Fields, options: {
+    pluralForm?: string;
+    description?: string;
+  });
+  get metadata(): TailorDBTypeConfig;
+  hooks(hooks: Hooks<Fields>): this;
+  validate(validators: Validators<Fields>): this;
+  features(features: Omit<TypeFeatures, "pluralForm">): this;
+  indexes(...indexes: IndexDef<this>[]): this;
+  files<const F extends string>(files: Record<F, string> & Partial<Record<keyof output<this>, never>>): this;
+  permission<U extends object = User, P extends TailorTypePermission<U, output<this>> = TailorTypePermission<U, output<this>>>(permission: P): TailorDBType<Fields, U>;
+  gqlPermission<U extends object = User, P extends TailorTypeGqlPermission<U> = TailorTypeGqlPermission<U>>(permission: P): TailorDBType<Fields, U>;
+  description(description: string): this;
+  /**
+   * Pick specific fields from the type
+   * @param keys - Array of field keys to pick
+   * @param options - Optional field options to apply to picked fields
+   * @returns An object containing only the specified fields
+   */
+  pickFields<K extends keyof Fields, const Opt extends FieldOptions>(keys: K[], options: Opt): { [P in K]: Fields[P] extends TailorDBField<infer D, infer _O> ? TailorDBField<Omit<D, "array"> & {
+    array: Opt extends {
+      array: true;
+    } ? true : D["array"];
+  }, FieldOutput<TailorToTs[D["type"]], Opt>> : never };
+  /**
+   * Omit specific fields from the type
+   * @param keys - Array of field keys to omit
+   * @returns An object containing all fields except the specified ones
+   */
+  omitFields<K extends keyof Fields>(keys: K[]): Omit<Fields, K>;
+}
+type TailorDBInstance<Fields extends Record<string, TailorDBField<any, any>> = any, User extends object = InferredAttributeMap> = InstanceType<typeof TailorDBType<Fields, User>>;
+declare const idField: TailorDBField<{
+  type: "uuid";
+  array: false;
+}, string>;
+type idField = typeof idField;
+type DBType<F extends {
+  id?: never;
+} & Record<string, TailorDBField<any, any>>> = TailorDBInstance<{
+  id: idField;
+} & F>;
+/**
+ * Creates a new database type with the specified fields
+ * @param name - The name of the type, or a tuple of [name, pluralForm]
+ * @param fields - The field definitions for the type
+ * @returns A new TailorDBType instance
+ */
+declare function dbType<const F extends {
+  id?: never;
+} & Record<string, TailorDBField<any, any>>>(name: string | [string, string], fields: F): DBType<F>;
+/**
+ * Creates a new database type with the specified fields and description
+ * @param name - The name of the type, or a tuple of [name, pluralForm]
+ * @param description - A description of the type
+ * @param fields - The field definitions for the type
+ * @returns A new TailorDBType instance
+ */
+declare function dbType<const F extends {
+  id?: never;
+} & Record<string, TailorDBField<any, any>>>(name: string | [string, string], description: string, fields: F): DBType<F>;
+declare const db: {
+  type: typeof dbType;
+  uuid: typeof uuid;
+  string: typeof string;
+  bool: typeof bool;
+  int: typeof int;
+  float: typeof float;
+  date: typeof date;
+  datetime: typeof datetime;
+  time: typeof time;
+  enum: typeof _enum;
+  object: typeof object;
+  fields: {
+    timestamps: () => {
+      createdAt: TailorDBField<{
+        type: "datetime";
+        array: false;
+        hooks?: {
+          create: true;
+          update: false;
+        } | undefined;
+        serial: false;
+        description: true;
+      }, string>;
+      updatedAt: TailorDBField<{
+        type: "datetime";
+        array: false;
+        hooks?: {
+          create: false;
+          update: true;
+        } | undefined;
+        serial: false;
+        description: true;
+      }, string | null>;
+    };
+  };
+};
+//#endregion
+//#region src/configure/services/executor/types.d.ts
+type ExecutorServiceConfig = {
+  files: string[];
+  ignores?: string[];
+};
+type ExecutorServiceInput = ExecutorServiceConfig;
+//#endregion
+//#region src/configure/services/resolver/types.d.ts
+type ResolverServiceConfig = {
+  files: string[];
+  ignores?: string[];
+};
+type ResolverServiceInput = {
+  [namespace: string]: ResolverServiceConfig;
+};
+//#endregion
+//#region src/parser/service/idp/schema.d.ts
+declare const IdPSchema: z.core.$ZodBranded<z.ZodObject<{
+  name: z.ZodString;
+  authorization: z.ZodUnion<readonly [z.ZodLiteral<"insecure">, z.ZodLiteral<"loggedIn">, z.ZodObject<{
+    cel: z.ZodString;
+  }, z.core.$strip>]>;
+  clients: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, "IdPConfig">;
+//#endregion
+//#region src/parser/service/idp/types.d.ts
+type IdPInput = z.input<typeof IdPSchema>;
+//#endregion
+//#region src/configure/services/idp/index.d.ts
+declare const idpDefinitionBrand: unique symbol;
+type IdpDefinitionBrand = {
+  readonly [idpDefinitionBrand]: true;
+};
+declare function defineIdp<const TClients extends string[]>(name: string, config: Omit<IdPInput, "name" | "clients"> & {
+  clients: TClients;
+}): {
+  readonly name: string;
+  readonly provider: (providerName: string, clientName: TClients[number]) => {
+    readonly name: string;
+    readonly kind: "BuiltInIdP";
+    readonly namespace: string;
+    readonly clientName: TClients[number];
+  };
+  readonly authorization: "insecure" | "loggedIn" | {
+    cel: string;
+  };
+  readonly clients: TClients;
+} & IdpDefinitionBrand;
+type IdPConfig = Omit<ReturnType<typeof defineIdp>, "provider">;
+//#endregion
+//#region src/parser/service/staticwebsite/schema.d.ts
+declare const StaticWebsiteSchema: z.core.$ZodBranded<z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  allowedIpAddresses: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, "StaticWebsiteConfig">;
+//#endregion
+//#region src/parser/service/staticwebsite/types.d.ts
+type StaticWebsiteInput = z.input<typeof StaticWebsiteSchema>;
+//#endregion
+//#region src/configure/services/staticwebsite/index.d.ts
+declare const staticWebsiteDefinitionBrand: unique symbol;
+type StaticWebsiteDefinitionBrand = {
+  readonly [staticWebsiteDefinitionBrand]: true;
+};
+declare function defineStaticWebSite(name: string, config: Omit<StaticWebsiteInput, "name">): {
+  readonly name: string;
+  readonly url: `${string}:url`;
+  readonly description?: string | undefined;
+  readonly allowedIpAddresses?: string[] | undefined;
+} & StaticWebsiteDefinitionBrand;
+type StaticWebsiteConfig = Omit<ReturnType<typeof defineStaticWebSite>, "url">;
+//#endregion
+//#region src/parser/generator-config/index.d.ts
+declare const CodeGeneratorSchema: z.ZodObject<{
+  id: z.ZodString;
+  description: z.ZodString;
+  processType: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  processResolver: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  processExecutor: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  processTailorDBNamespace: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+  processResolverNamespace: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+  aggregate: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodAny>;
+}, z.core.$strip>;
+declare const BaseGeneratorConfigSchema: z.ZodUnion<readonly [z.ZodTuple<[z.ZodLiteral<"@tailor-platform/kysely-type">, z.ZodObject<{
+  distPath: z.ZodString;
+}, z.core.$strip>], null>, z.ZodTuple<[z.ZodLiteral<"@tailor-platform/seed">, z.ZodObject<{
+  distPath: z.ZodString;
+  machineUserName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], null>, z.ZodObject<{
+  id: z.ZodString;
+  description: z.ZodString;
+  processType: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  processResolver: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  processExecutor: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  processTailorDBNamespace: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+  processResolverNamespace: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+  aggregate: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodAny>;
+}, z.core.$strip>]>;
+/**
+ * Creates a GeneratorConfigSchema with built-in generator support
+ * @param builtinGenerators - Map of generator IDs to their constructor functions
+ */
+declare function createGeneratorConfigSchema(builtinGenerators: Map<string, (options: any) => CodeGeneratorBase>): z.core.$ZodBranded<z.ZodPipe<z.ZodUnion<readonly [z.ZodTuple<[z.ZodLiteral<"@tailor-platform/kysely-type">, z.ZodObject<{
+  distPath: z.ZodString;
+}, z.core.$strip>], null>, z.ZodTuple<[z.ZodLiteral<"@tailor-platform/seed">, z.ZodObject<{
+  distPath: z.ZodString;
+  machineUserName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], null>, z.ZodObject<{
+  id: z.ZodString;
+  description: z.ZodString;
+  processType: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  processResolver: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  processExecutor: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  processTailorDBNamespace: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+  processResolverNamespace: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+  aggregate: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodAny>;
+}, z.core.$strip>]>, z.ZodTransform<{
+  id: string;
+  description: string;
+  processType: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  processResolver: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  processExecutor: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  aggregate: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodAny>;
+  processTailorDBNamespace?: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut> | undefined;
+  processResolverNamespace?: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut> | undefined;
+}, ["@tailor-platform/kysely-type", {
+  distPath: string;
+}] | ["@tailor-platform/seed", {
+  distPath: string;
+  machineUserName?: string | undefined;
+}] | {
+  id: string;
+  description: string;
+  processType: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  processResolver: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  processExecutor: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+  aggregate: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodAny>;
+  processTailorDBNamespace?: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut> | undefined;
+  processResolverNamespace?: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut> | undefined;
+}>>, "CodeGenerator">;
+type GeneratorConfigSchemaType = ReturnType<typeof createGeneratorConfigSchema>;
+type Generator = z.output<GeneratorConfigSchemaType>;
+//#endregion
+//#region src/parser/generator-config/types.d.ts
+type GeneratorConfig = z.input<typeof BaseGeneratorConfigSchema>;
+type CodeGeneratorBase = z.output<typeof CodeGeneratorSchema>;
+//#endregion
+//#region src/configure/config.d.ts
+interface AppConfig<Auth extends AuthConfig = AuthConfig, Idp extends IdPConfig[] = IdPConfig[], StaticWebsites extends StaticWebsiteConfig[] = StaticWebsiteConfig[]> {
+  name: string;
+  cors?: string[];
+  allowedIPAddresses?: string[];
+  disableIntrospection?: boolean;
+  db?: TailorDBServiceInput;
+  resolver?: ResolverServiceInput;
+  idp?: Idp;
+  auth?: Auth;
+  executor?: ExecutorServiceInput;
+  staticWebsites?: StaticWebsites;
+}
+declare function defineConfig<const Config extends AppConfig>(config: Config): Config;
+declare function defineGenerators(...configs: GeneratorConfig[]): (["@tailor-platform/kysely-type", {
+  distPath: string;
+}] | ["@tailor-platform/seed", {
+  distPath: string;
+  machineUserName?: string | undefined;
+}] | {
+  id: string;
+  description: string;
+  processType: zod_v4_core0.$InferInnerFunctionType<zod_v4_core0.$ZodFunctionArgs, zod_v4_core0.$ZodFunctionOut>;
+  processResolver: zod_v4_core0.$InferInnerFunctionType<zod_v4_core0.$ZodFunctionArgs, zod_v4_core0.$ZodFunctionOut>;
+  processExecutor: zod_v4_core0.$InferInnerFunctionType<zod_v4_core0.$ZodFunctionArgs, zod_v4_core0.$ZodFunctionOut>;
+  aggregate: zod_v4_core0.$InferInnerFunctionType<zod_v4_core0.$ZodFunctionArgs, zod0.ZodAny>;
+  processTailorDBNamespace?: zod_v4_core0.$InferInnerFunctionType<zod_v4_core0.$ZodFunctionArgs, zod_v4_core0.$ZodFunctionOut> | undefined;
+  processResolverNamespace?: zod_v4_core0.$InferInnerFunctionType<zod_v4_core0.$ZodFunctionArgs, zod_v4_core0.$ZodFunctionOut> | undefined;
+})[];
+//#endregion
+//#region src/parser/service/executor/schema.d.ts
+declare const RecordTriggerSchema: z.ZodObject<{
+  kind: z.ZodEnum<{
+    recordCreated: "recordCreated";
+    recordUpdated: "recordUpdated";
+    recordDeleted: "recordDeleted";
+  }>;
+  typeName: z.ZodString;
+  condition: z.ZodOptional<z.ZodCustom<Function, Function>>;
+}, z.core.$strip>;
+declare const ResolverExecutedTriggerSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"resolverExecuted">;
+  resolverName: z.ZodString;
+  condition: z.ZodOptional<z.ZodCustom<Function, Function>>;
+}, z.core.$strip>;
+declare const ScheduleTriggerSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"schedule">;
+  cron: z.ZodString;
+  timezone: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+declare const IncomingWebhookTriggerSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"incomingWebhook">;
+}, z.core.$strip>;
+declare const FunctionOperationSchema: z.ZodObject<{
+  kind: z.ZodEnum<{
+    function: "function";
+    jobFunction: "jobFunction";
+  }>;
+  body: z.ZodCustom<Function, Function>;
+  invoker: z.ZodOptional<z.ZodObject<{
+    authName: z.ZodString;
+    machineUser: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const GqlOperationSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"graphql">;
+  appName: z.ZodString;
+  query: z.ZodString;
+  variables: z.ZodOptional<z.ZodCustom<Function, Function>>;
+  invoker: z.ZodOptional<z.ZodObject<{
+    authName: z.ZodString;
+    machineUser: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const WebhookOperationSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"webhook">;
+  url: z.ZodCustom<Function, Function>;
+  body: z.ZodOptional<z.ZodCustom<Function, Function>>;
+  headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    vault: z.ZodString;
+    key: z.ZodString;
+  }, z.core.$strip>]>>>;
+}, z.core.$strip>;
+declare const ExecutorSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  disabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+  trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodEnum<{
+      recordCreated: "recordCreated";
+      recordUpdated: "recordUpdated";
+      recordDeleted: "recordDeleted";
+    }>;
+    typeName: z.ZodString;
+    condition: z.ZodOptional<z.ZodCustom<Function, Function>>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"resolverExecuted">;
+    resolverName: z.ZodString;
+    condition: z.ZodOptional<z.ZodCustom<Function, Function>>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"schedule">;
+    cron: z.ZodString;
+    timezone: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"incomingWebhook">;
+  }, z.core.$strip>], "kind">;
+  operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodEnum<{
+      function: "function";
+      jobFunction: "jobFunction";
+    }>;
+    body: z.ZodCustom<Function, Function>;
+    invoker: z.ZodOptional<z.ZodObject<{
+      authName: z.ZodString;
+      machineUser: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"graphql">;
+    appName: z.ZodString;
+    query: z.ZodString;
+    variables: z.ZodOptional<z.ZodCustom<Function, Function>>;
+    invoker: z.ZodOptional<z.ZodObject<{
+      authName: z.ZodString;
+      machineUser: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"webhook">;
+    url: z.ZodCustom<Function, Function>;
+    body: z.ZodOptional<z.ZodCustom<Function, Function>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      vault: z.ZodString;
+      key: z.ZodString;
+    }, z.core.$strip>]>>>;
+  }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+//#endregion
+//#region src/parser/service/executor/types.d.ts
+type RecordTrigger = z.infer<typeof RecordTriggerSchema>;
+type ResolverExecutedTrigger = z.infer<typeof ResolverExecutedTriggerSchema>;
+type ScheduleTriggerInput = z.input<typeof ScheduleTriggerSchema>;
+type IncomingWebhookTrigger = z.infer<typeof IncomingWebhookTriggerSchema>;
+type FunctionOperation = z.infer<typeof FunctionOperationSchema>;
+type GqlOperation = z.infer<typeof GqlOperationSchema>;
+type WebhookOperation = z.infer<typeof WebhookOperationSchema>;
+type Executor = z.infer<typeof ExecutorSchema>;
+type ExecutorInput = z.input<typeof ExecutorSchema>;
+//#endregion
+export { AllowedValues, AllowedValuesOutput, AppConfig, ArrayFieldOutput, AuthConfig, type AuthServiceInput, type BuiltinIdP, CodeGeneratorBase, Executor, ExecutorInput, ExecutorServiceConfig, ExecutorServiceInput, FieldMetadata, FieldOptions, FieldOutput, FunctionOperation, Generator, GqlOperation, type IDToken, IdPConfig, type IdProviderConfig, IncomingWebhookTrigger, InferFieldsOutput, type OAuth2Client, type OAuth2ClientGrantType, type OIDC, PermissionCondition, QueryType, RecordTrigger, Resolver, ResolverExecutedTrigger, ResolverInput, ResolverServiceConfig, ResolverServiceInput, type SAML, type SCIMAttribute, type SCIMAttributeMapping, type SCIMAttributeType, type SCIMAuthorization, type SCIMConfig, type SCIMResource, ScheduleTriggerInput, StaticWebsiteConfig, TailorDBType, TailorDBTypeConfig, TailorField, TailorTypeGqlPermission, TailorTypePermission, TailorUser, type TenantProviderConfig, type UserAttributeKey, type UserAttributeListKey, type UserAttributeMap, type UsernameFieldKey, type ValueOperand, WebhookOperation, db, defineAuth, defineConfig, defineGenerators, defineIdp, defineStaticWebSite, output, unauthenticatedTailorUser };