studiocms 0.3.0 → 0.4.1

package/dist/schemas/config/index.js

@@ -1,61 +1,119 @@
-import { z } from "astro/zod";
+import * as Schema from "effect/Schema";
 import { RobotsTXTConfigSchema } from "../../integrations/robots/schema.js";
-import { availableTranslationsKeys } from "../../virtuals/i18n/v-files.js";
-import { authConfigSchema } from "./auth.js";
-import { dashboardConfigSchema } from "./dashboard.js";
-import { dbConfigSchema } from "./db.js";
-import { developerConfigSchema } from "./developer.js";
-import { SDKSchema } from "./sdk.js";
-const StudioCMSOptionsSchema = z.object({
-  dbStartPage: z.boolean().optional().default(true),
-  verbose: z.boolean().optional().default(false),
-  logLevel: z.union([
-    z.literal("All"),
-    z.literal("Fatal"),
-    z.literal("Error"),
-    z.literal("Warning"),
-    z.literal("Info"),
-    z.literal("Debug"),
-    z.literal("Trace"),
-    z.literal("None")
-  ]).optional().default("Info"),
-  db: dbConfigSchema,
-  plugins: z.custom().optional(),
-  storageManager: z.custom().optional(),
-  componentRegistry: z.record(z.string()).optional(),
-  locale: z.object({
-    dateLocale: z.string().optional().default("en-us"),
-    dateTimeFormat: z.custom().optional().default({
-      year: "numeric",
-      month: "short",
-      day: "numeric"
-    }),
-    i18n: z.object({
-      defaultLocale: z.string().superRefine((val, ctx) => {
-        if (!availableTranslationsKeys.includes(val)) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `Locale '${val}' is not supported. Available locales are: ${availableTranslationsKeys.join(
-              ", "
-            )}`
-          });
-          return z.NEVER;
-        }
-      }).optional().default("en")
-    }).optional().default({})
-  }).optional().default({}),
-  features: z.object({
-    robotsTXT: z.union([RobotsTXTConfigSchema, z.boolean()]).optional().default(true),
-    injectQuickActionsMenu: z.boolean().optional().default(true),
-    sdk: SDKSchema,
-    dashboardConfig: dashboardConfigSchema,
-    authConfig: authConfigSchema,
-    developerConfig: developerConfigSchema,
-    preferredImageService: z.string().optional(),
-    webVitals: z.boolean().optional().default(false)
-  }).optional().default({})
-}).optional().default({});
+import { BooleanDefaultFalse, BooleanDefaultTrue, OptionalWithDefaults } from "../custom.js";
+import { DateTimeFormatOptions, I18nKeySchema } from "../external-schemas.js";
+import { StudioCMSPluginSchema, StudioCMSStorageManagerSchema } from "../plugins/index.js";
+import { ApiConfigSchema } from "./api.js";
+import { AuthConfigSchema } from "./auth.js";
+import { DashboardConfigSchema } from "./dashboard.js";
+import { DbConfigSchema } from "./db.js";
+import { DeveloperConfigSchema } from "./developer.js";
+import { SDKConfigSchema } from "./sdk.js";
+const LocaleI18nConfigSchema = Schema.Struct({
+  defaultLocale: OptionalWithDefaults(I18nKeySchema, "en").annotations({
+    description: "Default Locale - Set the default locale for the dashboard translations"
+  })
+}).annotations({
+  title: "Locale I18n Configuration",
+  description: "Locale I18n Configuration - Configure the internationalization settings for the dashboard",
+  identifier: "LocaleI18nConfig"
+});
+const LocaleConfigSchema = Schema.Struct({
+  dateLocale: OptionalWithDefaults(Schema.String, "en-us").annotations({
+    description: "Date Locale - Set the locale for date formatting in the dashboard"
+  }),
+  dateTimeFormat: OptionalWithDefaults(DateTimeFormatOptions, {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  }).annotations({
+    description: "Date Time Format - Set the date and time formatting options for the dashboard"
+  }),
+  i18n: OptionalWithDefaults(LocaleI18nConfigSchema, {}).annotations({
+    description: "I18n Configuration - Configure the internationalization settings for the dashboard"
+  })
+});
+const StudioCMSRobotsTXTConfigSchema = Schema.Union(Schema.Boolean, RobotsTXTConfigSchema);
+const FeaturesConfigSchema = Schema.Struct({
+  robotsTXT: OptionalWithDefaults(StudioCMSRobotsTXTConfigSchema, true).annotations({
+    description: "Robots TXT Configuration - Configure the robots.txt settings for the dashboard, allowing for customization of the robots.txt file served by the dashboard to control how search engines and web crawlers interact with the dashboard."
+  }),
+  injectQuickActionsMenu: BooleanDefaultTrue.annotations({
+    description: "Inject Quick Actions Menu - Allows injecting a quick actions menu in the dashboard for easy access to common actions"
+  }),
+  sdk: OptionalWithDefaults(SDKConfigSchema, true).annotations({
+    description: "SDK Configuration with Default - Allows configuring the SDK with cache settings, defaults to enabled with a 5 minute lifetime"
+  }),
+  dashboardConfig: OptionalWithDefaults(DashboardConfigSchema, {}).annotations({
+    description: "Dashboard Configuration - Configure settings related to the dashboard, such as enabling/disabling the dashboard, customizing the favicon, and configuring security settings."
+  }),
+  authConfig: OptionalWithDefaults(AuthConfigSchema, {}).annotations({
+    description: "Authentication Configuration - Configure settings related to authentication, such as enabling/disabling authentication and configuring authentication providers."
+  }),
+  developerConfig: OptionalWithDefaults(DeveloperConfigSchema, {}).annotations({
+    description: "Developer Configuration - Configure settings related to development features, such as enabling/disabling demo mode."
+  }),
+  preferredImageService: Schema.optional(Schema.String).annotations({
+    description: "Preferred Image Service - Set the preferred image service for handling image processing tasks, such as resizing and optimization. This can be set to a specific image service provider or left undefined to use the default image service."
+  }),
+  webVitals: BooleanDefaultFalse.annotations({
+    description: "Web Vitals - Enable or disable the collection of web vitals metrics for performance monitoring and optimization."
+  }),
+  api: OptionalWithDefaults(ApiConfigSchema, {}).annotations({
+    description: "API Configuration - Configure the API settings for the dashboard, such as enabling/disabling the API documentation."
+  })
+}).annotations({
+  title: "Features Configuration",
+  description: "Features Configuration - Configure various features for the dashboard, such as enabling/disabling the dashboard, authentication, SDK settings, and more.",
+  identifier: "FeaturesConfig"
+});
+const StudioCMSOptionsSchema = Schema.Struct({
+  dbStartPage: BooleanDefaultTrue.annotations({
+    description: "DB Start Page - Whether to start into setup mode"
+  }),
+  verbose: BooleanDefaultFalse.annotations({
+    description: "Verbose Logging - Whether to enable verbose logging for debugging purposes"
+  }),
+  logLevel: Schema.optionalWith(
+    Schema.Literal("All", "Fatal", "Error", "Warning", "Info", "Debug", "Trace", "None"),
+    {
+      default: () => "Info"
+    }
+  ).annotations({
+    description: "Log Level - Set the LogLevel for Effect based code"
+  }),
+  db: OptionalWithDefaults(DbConfigSchema, {}).annotations({
+    description: "Database Configuration - Configure the database settings for StudioCMS"
+  }),
+  plugins: Schema.optional(Schema.mutable(Schema.Array(StudioCMSPluginSchema))).annotations({
+    description: "Plugins - Add plugins to the StudioCMS to extend its functionality"
+  }),
+  storageManager: Schema.optional(StudioCMSStorageManagerSchema).annotations({
+    description: "Storage Manager - Configure the storage manager for handling file uploads and storage"
+  }),
+  componentRegistry: Schema.optional(
+    Schema.Record({
+      key: Schema.String,
+      value: Schema.String
+    })
+  ).annotations({
+    description: "Component Registry - A record of custom components that can be used in the dashboard, where the key is the component name and the value is the path to the component"
+  }),
+  locale: OptionalWithDefaults(LocaleConfigSchema, {}).annotations({
+    description: "Locale Configuration - Configure locale specific settings for the dashboard"
+  }),
+  features: OptionalWithDefaults(FeaturesConfigSchema, {}).annotations({
+    description: "Features Configuration - Configure various features for the dashboard, such as enabling/disabling the dashboard, authentication, SDK settings, and more."
+  })
+}).annotations({
+  title: "StudioCMS Configuration",
+  description: "Main configuration schema for StudioCMS, including database settings, plugins, storage manager, locale settings, and feature flags.",
+  identifier: "StudioCMSConfig"
+});
 export {
+  FeaturesConfigSchema,
+  LocaleConfigSchema,
+  LocaleI18nConfigSchema,
   StudioCMSOptionsSchema,
-  dashboardConfigSchema
+  StudioCMSRobotsTXTConfigSchema
 };

package/dist/schemas/config/sdk.d.ts

@@ -1,216 +1,70 @@
-import { z } from 'astro/zod';
-export declare const TimeUnitSchema: z.ZodUnion<[z.ZodLiteral<"m">, z.ZodLiteral<"h">]>;
-export declare const TimeStringSchema: z.ZodEffects<z.ZodString, number, string>;
-export type TimeString = typeof TimeStringSchema._input;
+import { Duration } from 'effect';
+import * as Schema from 'effect/Schema';
 /**
- * Schema for cache configuration.
+ * Schema for the cache lifetime configuration, which is an optional duration that defaults to 5 minutes if not provided.
  */
-export declare const CacheConfigSchema: z.ZodObject<{
-    /**
-     * Cache Lifetime
-     *
-     * `{number}{unit}` - e.g. '5m' for 5 minutes or '1h' for 1 hour
-     * @default '5m'
-     */
-    lifetime: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, number, string>>>;
-}, "strip", z.ZodTypeAny, {
-    lifetime: number;
-}, {
-    lifetime?: string | undefined;
+export declare const LifeTimeSchema: Schema.optionalWith<typeof Schema.DurationFromSelf, {
+    default: () => Duration.Duration;
 }>;
 /**
- * Schema for processed cache configuration.
- *
- * Extends the base CacheConfigSchema with additional properties.
- *
- * Properties:
- * - `enabled` (boolean): Indicates if the cache is enabled.
- *   - @default true
- */
-export declare const ProcessedCacheConfigSchema: z.ZodObject<{
-    /**
-     * Cache Enabled
-     *
-     * @default true
-     */
-    enabled: z.ZodDefault<z.ZodBoolean>;
-    /**
-     * Cache Lifetime
-     *
-     * `{number}{unit}` - e.g. '5m' for 5 minutes or '1h' for 1 hour
-     * @default '5m'
-     */
-    lifetime: z.ZodDefault<z.ZodEffects<z.ZodString, number, string>>;
-}, "strip", z.ZodTypeAny, {
-    lifetime: number;
-    enabled: boolean;
-}, {
-    lifetime?: string | undefined;
-    enabled?: boolean | undefined;
-}>;
-/**
- * Represents the configuration for the cache.
- *
- * This type is inferred from the `CacheConfigSchema` using Zod's `infer` method.
- * It ensures that the cache configuration adheres to the schema defined in `CacheConfigSchema`.
+ * Schema for the cache configuration, which can be either a boolean to enable/disable caching or an object to specify the cache lifetime.
  */
-export type CacheConfig = z.infer<typeof CacheConfigSchema>;
-/**
- * Represents the processed cache configuration inferred from the ProcessedCacheConfigSchema.
- *
- * This type is used to define the structure of the cache configuration after it has been
- * processed and validated by the schema.
- */
-export type ProcessedCacheConfig = z.infer<typeof ProcessedCacheConfigSchema>;
+export declare const CacheConfigSchema: Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
+    lifetime: Schema.optionalWith<typeof Schema.DurationFromSelf, {
+        default: () => Duration.Duration;
+    }>;
+}>]>;
 /**
- * Schema for SDK cache configuration.
- *
- * This schema allows for either a boolean value or a more detailed cache configuration object.
- *
- * - If a boolean value is provided:
- *   - `true`: Enables caching with a default lifetime.
- *   - `false`: Disables caching.
- * - If a cache configuration object is provided, it must conform to `CacheConfigSchema`.
- *
- * The schema is optional and defaults to `true` (enabled with default lifetime).
- *
- * The transformation ensures that the resulting configuration is of type `ProcessedCacheConfig`:
- * - If a boolean value is provided, it is transformed into an object with `enabled` and `lifetime` properties.
- * - If a cache configuration object is provided, it is transformed to ensure `enabled` is always `true`.
+ * Default cache lifetime in milliseconds (5 minutes).
  */
-export declare const SDKCacheSchema: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
-    /**
-     * Cache Lifetime
-     *
-     * `{number}{unit}` - e.g. '5m' for 5 minutes or '1h' for 1 hour
-     * @default '5m'
-     */
-    lifetime: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, number, string>>>;
-}, "strip", z.ZodTypeAny, {
-    lifetime: number;
-}, {
-    lifetime?: string | undefined;
-}>]>>>, {
-    lifetime: number;
-    enabled: boolean;
-}, boolean | {
-    lifetime?: string | undefined;
-} | undefined>;
+export declare const InputSDKConfigSchema: Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
+    cacheConfig: Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
+        lifetime: Schema.optionalWith<typeof Schema.DurationFromSelf, {
+            default: () => Duration.Duration;
+        }>;
+    }>]>;
+}>]>;
 /**
- * Schema for processing SDK configuration.
+ * Schema for the processed cache configuration, which has a boolean to indicate if caching is enabled and a number for the cache lifetime in milliseconds.
  */
-export declare const ProcessedSDKSchema: z.ZodObject<{
-    /**
-     * Cache Configuration
-     *
-     * @default cacheConfig: { lifetime: '5m' }
-     */
-    cacheConfig: z.ZodObject<{
-        /**
-         * Cache Enabled
-         *
-         * @default true
-         */
-        enabled: z.ZodDefault<z.ZodBoolean>;
-        /**
-         * Cache Lifetime
-         *
-         * `{number}{unit}` - e.g. '5m' for 5 minutes or '1h' for 1 hour
-         * @default '5m'
-         */
-        lifetime: z.ZodDefault<z.ZodEffects<z.ZodString, number, string>>;
-    }, "strip", z.ZodTypeAny, {
-        lifetime: number;
-        enabled: boolean;
-    }, {
-        lifetime?: string | undefined;
-        enabled?: boolean | undefined;
+export declare const OutputSDKConfigSchema: Schema.Struct<{
+    cacheConfig: Schema.Struct<{
+        lifetime: typeof Schema.Number;
+        enabled: typeof Schema.Boolean;
     }>;
-}, "strip", z.ZodTypeAny, {
-    cacheConfig: {
-        lifetime: number;
-        enabled: boolean;
-    };
-}, {
-    cacheConfig: {
-        lifetime?: string | undefined;
-        enabled?: boolean | undefined;
-    };
 }>;
 /**
- * Type definition for the processed SDK configuration.
+ * Gets the default cache configuration based on whether caching is enabled or not.
  *
- * This type is inferred from the `ProcessedSDKSchema` using Zod's `infer` method.
- * It represents the structure of the SDK configuration after it has been processed.
+ * @param enabled - A boolean indicating whether caching is enabled or not.
+ * @returns An object containing the cache configuration with lifetime in milliseconds and enabled status.
  */
-export type ProcessedSDKConfig = z.infer<typeof ProcessedSDKSchema>;
-export type StudioCMS_SDKOptions = boolean | {
-    /**
-     * Cache Configuration
-     *
-     * @default cacheConfig: { lifetime: '5m' }
-     */
-    cacheConfig?: boolean | {
-        /**
-         * Cache Lifetime
-         *
-         * `{number}{unit}` - e.g. '5m' for 5 minutes or '1h' for 1 hour
-         * @default '5m'
-         */
-        lifetime?: string | undefined;
-    } | undefined;
-} | undefined;
-export interface StudioCMS_SDKConfig {
+export declare const getDefaultCacheConfig: (enabled: boolean) => {
     cacheConfig: {
         lifetime: number;
         enabled: boolean;
     };
-}
+};
 /**
- * SDKSchema is a Zod schema that validates the SDK configuration.
- * It can either be a boolean or an object containing cache configuration.
- *
- * If it is a boolean, it defaults to `true` and transforms into an object
- * with default cache configuration.
- *
- * If it is an object, it must contain the `cacheConfig` property which is
- * validated by the `SDKCacheSchema`.
+ * Processes the input SDK configuration and returns the processed cache configuration.
  */
-export declare const SDKSchema: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
-    cacheConfig: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
-        /**
-         * Cache Lifetime
-         *
-         * `{number}{unit}` - e.g. '5m' for 5 minutes or '1h' for 1 hour
-         * @default '5m'
-         */
-        lifetime: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, number, string>>>;
-    }, "strip", z.ZodTypeAny, {
-        lifetime: number;
-    }, {
-        lifetime?: string | undefined;
-    }>]>>>, {
-        lifetime: number;
-        enabled: boolean;
-    }, boolean | {
-        lifetime?: string | undefined;
-    } | undefined>;
-}, "strip", z.ZodTypeAny, {
-    cacheConfig: {
-        lifetime: number;
-        enabled: boolean;
-    };
-}, {
-    cacheConfig?: boolean | {
-        lifetime?: string | undefined;
-    } | undefined;
-}>]>>>, {
-    cacheConfig: {
-        lifetime: number;
-        enabled: boolean;
-    };
-}, boolean | {
-    cacheConfig?: boolean | {
-        lifetime?: string | undefined;
-    } | undefined;
-} | undefined>;
+export declare const SDKConfigSchema: Schema.transform<Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
+    cacheConfig: Schema.Union<[typeof Schema.Boolean, Schema.Struct<{
+        lifetime: Schema.optionalWith<typeof Schema.DurationFromSelf, {
+            default: () => Duration.Duration;
+        }>;
+    }>]>;
+}>]>, Schema.Struct<{
+    cacheConfig: Schema.Struct<{
+        lifetime: typeof Schema.Number;
+        enabled: typeof Schema.Boolean;
+    }>;
+}>>;
+/**
+ * Type for the SDK configuration.
+ */
+export type SDKConfig = typeof SDKConfigSchema.Encoded;
+/**
+ * Resolved type for the SDK configuration.
+ */
+export type SDKConfigResolved = typeof SDKConfigSchema.Type;

package/dist/schemas/config/sdk.js

@@ -1,86 +1,74 @@
-import { z } from "astro/zod";
-import { defaultCacheLifeTime } from "../../consts.js";
-const TimeUnitSchema = z.union([z.literal("m"), z.literal("h")]);
-const TimeStringSchema = z.string().regex(/^\d+(m|h)$/, {
-  message: "Invalid time string format. Must be a number followed by 'm' or 'h'."
-}).transform((value) => {
-  const timeUnits = {
-    m: 60 * 1e3,
-    // Minutes to milliseconds
-    h: 60 * 60 * 1e3
-    // Hours to milliseconds
-  };
-  const match = value.match(/^(\d+)([mh])$/);
-  if (!match) {
-    throw new Error("Invalid time format. Use values like '5m', '1h', etc.");
-  }
-  const val = Number.parseInt(match[1], 10);
-  const unit = match[2];
-  return val * timeUnits[unit];
+import { Duration } from "effect";
+import * as Schema from "effect/Schema";
+import { DefaultCacheLifetime } from "../../consts.js";
+const LifeTimeSchema = Schema.optionalWith(Schema.DurationFromSelf, {
+  default: () => DefaultCacheLifetime
+}).annotations({
+  description: "Cache Lifetime - The duration for which the cache is valid"
 });
-const CacheConfigSchema = z.object({
-  /**
-   * Cache Lifetime
-   *
-   * `{number}{unit}` - e.g. '5m' for 5 minutes or '1h' for 1 hour
-   * @default '5m'
-   */
-  lifetime: TimeStringSchema.optional().default(defaultCacheLifeTime)
+const CacheConfigSchema = Schema.Union(
+  Schema.Boolean,
+  Schema.Struct({
+    lifetime: LifeTimeSchema
+  })
+).annotations({
+  description: "Cache Configuration - Allows enabling/disabling cache and setting cache lifetime"
 });
-const ProcessedCacheConfigSchema = z.object({
-  /**
-   * Cache Enabled
-   *
-   * @default true
-   */
-  enabled: z.boolean().default(true),
-  /**
-   * Cache Lifetime
-   *
-   * `{number}{unit}` - e.g. '5m' for 5 minutes or '1h' for 1 hour
-   * @default '5m'
-   */
-  lifetime: TimeStringSchema.default(defaultCacheLifeTime)
+const InputSDKConfigSchema = Schema.Union(
+  Schema.Boolean,
+  Schema.Struct({
+    cacheConfig: CacheConfigSchema
+  })
+).annotations({
+  description: "SDK Configuration - Allows configuring the SDK with cache settings"
 });
-const SDKCacheSchema = z.union([z.boolean(), CacheConfigSchema]).optional().default(true).transform((cacheConfig) => {
-  if (typeof cacheConfig === "boolean") {
-    return {
-      enabled: cacheConfig,
-      lifetime: TimeStringSchema.parse(defaultCacheLifeTime)
-    };
-  }
-  return { enabled: true, lifetime: cacheConfig.lifetime };
+const OutputSDKConfigSchema = Schema.Struct({
+  cacheConfig: Schema.Struct({
+    lifetime: Schema.Number,
+    enabled: Schema.Boolean
+  }).annotations({
+    description: "Processed Cache Configuration - Contains the processed cache settings with lifetime in milliseconds and enabled status"
+  })
+}).annotations({
+  description: "Processed SDK Configuration - The resulting configuration after processing the input SDK configuration"
 });
-const ProcessedSDKSchema = z.object({
-  /**
-   * Cache Configuration
-   *
-   * @default cacheConfig: { lifetime: '5m' }
-   */
-  cacheConfig: ProcessedCacheConfigSchema
+const getDefaultCacheConfig = (enabled) => ({
+  cacheConfig: {
+    lifetime: Duration.toMillis(DefaultCacheLifetime),
+    enabled
+  }
 });
-const SDKSchema = z.union([
-  z.boolean(),
-  z.object({
-    cacheConfig: SDKCacheSchema
-  })
-]).optional().default(true).transform((sdkConfig) => {
-  if (typeof sdkConfig === "boolean") {
+const SDKConfigSchema = Schema.transform(InputSDKConfigSchema, OutputSDKConfigSchema, {
+  strict: true,
+  decode: (input) => {
+    if (typeof input === "boolean") {
+      return getDefaultCacheConfig(input);
+    }
+    if (typeof input.cacheConfig === "boolean") {
+      return getDefaultCacheConfig(input.cacheConfig);
+    }
     return {
       cacheConfig: {
-        enabled: sdkConfig,
-        lifetime: TimeStringSchema.parse(defaultCacheLifeTime)
+        enabled: true,
+        lifetime: input.cacheConfig?.lifetime ? Duration.toMillis(input.cacheConfig.lifetime) : Duration.toMillis(DefaultCacheLifetime)
       }
     };
-  }
-  return sdkConfig;
+  },
+  encode: (output) => ({
+    cacheConfig: {
+      lifetime: Duration.millis(output.cacheConfig.lifetime)
+    }
+  })
+}).annotations({
+  title: "SDK Configuration",
+  description: "Configuration options related to the SDK, including cache settings",
+  identifier: "SDKConfig"
 });
 export {
   CacheConfigSchema,
-  ProcessedCacheConfigSchema,
-  ProcessedSDKSchema,
-  SDKCacheSchema,
-  SDKSchema,
-  TimeStringSchema,
-  TimeUnitSchema
+  InputSDKConfigSchema,
+  LifeTimeSchema,
+  OutputSDKConfigSchema,
+  SDKConfigSchema,
+  getDefaultCacheConfig
 };

package/dist/schemas/custom.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Custom schema definitions for StudioCMS.
+ *
+ * These schemas are used to define the shape of custom configuration options for StudioCMS.
+ *
+ * @module customSchemas
+ * @description This module contains custom schema definitions for StudioCMS, including boolean and string schemas with default values, as well as a utility function for creating optional schemas with defaults.
+ */
+import * as Schema from 'effect/Schema';
+/**
+ * Schema definition for a Boolean value that defaults to true if not provided.
+ */
+export declare const BooleanDefaultTrue: Schema.optionalWith<typeof Schema.Boolean, {
+    default: () => true;
+}>;
+/**
+ * Schema definition for a Boolean value that defaults to false if not provided.
+ */
+export declare const BooleanDefaultFalse: Schema.optionalWith<typeof Schema.Boolean, {
+    default: () => false;
+}>;
+/**
+ * Schema definition for a String value that defaults to a provided default value if not provided.
+ *
+ * @param defaultValue - The default string value to use if the value is not provided.
+ * @returns A schema for a string with a default value.
+ */
+export declare const StringWithDefault: (defaultValue: string) => Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+    default: () => string;
+}>;
+/**
+ * Utility function to create an optional schema with a default value.
+ *
+ * @param schema - The schema to make optional with a default value.
+ * @param defaultValue - The default value to use if the value is not provided.
+ * @returns A schema that is optional and has a default value.
+ */
+export declare const OptionalWithDefaults: <A, I>(schema: Schema.Schema<A, I, never>, defaultValue: I) => Schema.optionalWith<Schema.Schema<A, I, never>, {
+    default: () => A;
+}>;