studiocms 0.1.0-beta.10

package/dist/runtime/decoder/util.js

@@ -0,0 +1,415 @@
+import { fromCodePoint, replaceCodePoint } from "./decode-codepoint.js";
+import { htmlDecodeTree } from "./decode-data-html.js";
+import { xmlDecodeTree } from "./decode-data-xml.js";
+var CharCodes = /* @__PURE__ */ ((CharCodes2) => {
+  CharCodes2[CharCodes2["NUM"] = 35] = "NUM";
+  CharCodes2[CharCodes2["SEMI"] = 59] = "SEMI";
+  CharCodes2[CharCodes2["EQUALS"] = 61] = "EQUALS";
+  CharCodes2[CharCodes2["ZERO"] = 48] = "ZERO";
+  CharCodes2[CharCodes2["NINE"] = 57] = "NINE";
+  CharCodes2[CharCodes2["LOWER_A"] = 97] = "LOWER_A";
+  CharCodes2[CharCodes2["LOWER_F"] = 102] = "LOWER_F";
+  CharCodes2[CharCodes2["LOWER_X"] = 120] = "LOWER_X";
+  CharCodes2[CharCodes2["LOWER_Z"] = 122] = "LOWER_Z";
+  CharCodes2[CharCodes2["UPPER_A"] = 65] = "UPPER_A";
+  CharCodes2[CharCodes2["UPPER_F"] = 70] = "UPPER_F";
+  CharCodes2[CharCodes2["UPPER_Z"] = 90] = "UPPER_Z";
+  return CharCodes2;
+})(CharCodes || {});
+const TO_LOWER_BIT = 32;
+var BinTrieFlags = /* @__PURE__ */ ((BinTrieFlags2) => {
+  BinTrieFlags2[BinTrieFlags2["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
+  BinTrieFlags2[BinTrieFlags2["BRANCH_LENGTH"] = 16256] = "BRANCH_LENGTH";
+  BinTrieFlags2[BinTrieFlags2["JUMP_TABLE"] = 127] = "JUMP_TABLE";
+  return BinTrieFlags2;
+})(BinTrieFlags || {});
+function isNumber(code) {
+  return code >= 48 /* ZERO */ && code <= 57 /* NINE */;
+}
+function isHexadecimalCharacter(code) {
+  return code >= 65 /* UPPER_A */ && code <= 70 /* UPPER_F */ || code >= 97 /* LOWER_A */ && code <= 102 /* LOWER_F */;
+}
+function isAsciiAlphaNumeric(code) {
+  return code >= 65 /* UPPER_A */ && code <= 90 /* UPPER_Z */ || code >= 97 /* LOWER_A */ && code <= 122 /* LOWER_Z */ || isNumber(code);
+}
+function isEntityInAttributeInvalidEnd(code) {
+  return code === 61 /* EQUALS */ || isAsciiAlphaNumeric(code);
+}
+var EntityDecoderState = /* @__PURE__ */ ((EntityDecoderState2) => {
+  EntityDecoderState2[EntityDecoderState2["EntityStart"] = 0] = "EntityStart";
+  EntityDecoderState2[EntityDecoderState2["NumericStart"] = 1] = "NumericStart";
+  EntityDecoderState2[EntityDecoderState2["NumericDecimal"] = 2] = "NumericDecimal";
+  EntityDecoderState2[EntityDecoderState2["NumericHex"] = 3] = "NumericHex";
+  EntityDecoderState2[EntityDecoderState2["NamedEntity"] = 4] = "NamedEntity";
+  return EntityDecoderState2;
+})(EntityDecoderState || {});
+var DecodingMode = /* @__PURE__ */ ((DecodingMode2) => {
+  DecodingMode2[DecodingMode2["Legacy"] = 0] = "Legacy";
+  DecodingMode2[DecodingMode2["Strict"] = 1] = "Strict";
+  DecodingMode2[DecodingMode2["Attribute"] = 2] = "Attribute";
+  return DecodingMode2;
+})(DecodingMode || {});
+class EntityDecoder {
+  constructor(decodeTree, emitCodePoint, errors) {
+    this.decodeTree = decodeTree;
+    this.emitCodePoint = emitCodePoint;
+    this.errors = errors;
+  }
+  /** The current state of the decoder. */
+  state = 0 /* EntityStart */;
+  /** Characters that were consumed while parsing an entity. */
+  consumed = 1;
+  /**
+   * The result of the entity.
+   *
+   * Either the result index of a numeric entity, or the codepoint of a
+   * numeric entity.
+   */
+  result = 0;
+  /** The current index in the decode tree. */
+  treeIndex = 0;
+  /** The number of characters that were consumed in excess. */
+  excess = 1;
+  /** The mode in which the decoder is operating. */
+  decodeMode = 1 /* Strict */;
+  /** Resets the instance to make it reusable. */
+  startEntity(decodeMode) {
+    this.decodeMode = decodeMode;
+    this.state = 0 /* EntityStart */;
+    this.result = 0;
+    this.treeIndex = 0;
+    this.excess = 1;
+    this.consumed = 1;
+  }
+  /**
+   * Write an entity to the decoder. This can be called multiple times with partial entities.
+   * If the entity is incomplete, the decoder will return -1.
+   *
+   * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the
+   * entity is incomplete, and resume when the next string is written.
+   *
+   * @param input The string containing the entity (or a continuation of the entity).
+   * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
+   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+   */
+  write(input, offset) {
+    switch (this.state) {
+      case 0 /* EntityStart */: {
+        if (input.charCodeAt(offset) === 35 /* NUM */) {
+          this.state = 1 /* NumericStart */;
+          this.consumed += 1;
+          return this.stateNumericStart(input, offset + 1);
+        }
+        this.state = 4 /* NamedEntity */;
+        return this.stateNamedEntity(input, offset);
+      }
+      case 1 /* NumericStart */: {
+        return this.stateNumericStart(input, offset);
+      }
+      case 2 /* NumericDecimal */: {
+        return this.stateNumericDecimal(input, offset);
+      }
+      case 3 /* NumericHex */: {
+        return this.stateNumericHex(input, offset);
+      }
+      case 4 /* NamedEntity */: {
+        return this.stateNamedEntity(input, offset);
+      }
+    }
+  }
+  /**
+   * Switches between the numeric decimal and hexadecimal states.
+   *
+   * Equivalent to the `Numeric character reference state` in the HTML spec.
+   *
+   * @param input The string containing the entity (or a continuation of the entity).
+   * @param offset The current offset.
+   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+   */
+  stateNumericStart(input, offset) {
+    if (offset >= input.length) {
+      return -1;
+    }
+    if ((input.charCodeAt(offset) | TO_LOWER_BIT) === 120 /* LOWER_X */) {
+      this.state = 3 /* NumericHex */;
+      this.consumed += 1;
+      return this.stateNumericHex(input, offset + 1);
+    }
+    this.state = 2 /* NumericDecimal */;
+    return this.stateNumericDecimal(input, offset);
+  }
+  addToNumericResult(input, start, end, base) {
+    if (start !== end) {
+      const digitCount = end - start;
+      this.result = this.result * base ** digitCount + Number.parseInt(input.substr(start, digitCount), base);
+      this.consumed += digitCount;
+    }
+  }
+  /**
+   * Parses a hexadecimal numeric entity.
+   *
+   * Equivalent to the `Hexademical character reference state` in the HTML spec.
+   *
+   * @param input The string containing the entity (or a continuation of the entity).
+   * @param offset The current offset.
+   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+   */
+  stateNumericHex(input, offset) {
+    const startIndex = offset;
+    while (offset < input.length) {
+      const char = input.charCodeAt(offset);
+      if (isNumber(char) || isHexadecimalCharacter(char)) {
+        offset += 1;
+      } else {
+        this.addToNumericResult(input, startIndex, offset, 16);
+        return this.emitNumericEntity(char, 3);
+      }
+    }
+    this.addToNumericResult(input, startIndex, offset, 16);
+    return -1;
+  }
+  /**
+   * Parses a decimal numeric entity.
+   *
+   * Equivalent to the `Decimal character reference state` in the HTML spec.
+   *
+   * @param input The string containing the entity (or a continuation of the entity).
+   * @param offset The current offset.
+   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+   */
+  stateNumericDecimal(input, offset) {
+    const startIndex = offset;
+    while (offset < input.length) {
+      const char = input.charCodeAt(offset);
+      if (isNumber(char)) {
+        offset += 1;
+      } else {
+        this.addToNumericResult(input, startIndex, offset, 10);
+        return this.emitNumericEntity(char, 2);
+      }
+    }
+    this.addToNumericResult(input, startIndex, offset, 10);
+    return -1;
+  }
+  /**
+   * Validate and emit a numeric entity.
+   *
+   * Implements the logic from the `Hexademical character reference start
+   * state` and `Numeric character reference end state` in the HTML spec.
+   *
+   * @param lastCp The last code point of the entity. Used to see if the
+   *               entity was terminated with a semicolon.
+   * @param expectedLength The minimum number of characters that should be
+   *                       consumed. Used to validate that at least one digit
+   *                       was consumed.
+   * @returns The number of characters that were consumed.
+   */
+  emitNumericEntity(lastCp, expectedLength) {
+    if (this.consumed <= expectedLength) {
+      this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);
+      return 0;
+    }
+    if (lastCp === 59 /* SEMI */) {
+      this.consumed += 1;
+    } else if (this.decodeMode === 1 /* Strict */) {
+      return 0;
+    }
+    this.emitCodePoint(replaceCodePoint(this.result), this.consumed);
+    if (this.errors) {
+      if (lastCp !== 59 /* SEMI */) {
+        this.errors.missingSemicolonAfterCharacterReference();
+      }
+      this.errors.validateNumericCharacterReference(this.result);
+    }
+    return this.consumed;
+  }
+  /**
+   * Parses a named entity.
+   *
+   * Equivalent to the `Named character reference state` in the HTML spec.
+   *
+   * @param input The string containing the entity (or a continuation of the entity).
+   * @param offset The current offset.
+   * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+   */
+  stateNamedEntity(input, offset) {
+    const { decodeTree } = this;
+    let current = decodeTree[this.treeIndex];
+    let valueLength = (current & 49152 /* VALUE_LENGTH */) >> 14;
+    for (; offset < input.length; offset++, this.excess++) {
+      const char = input.charCodeAt(offset);
+      this.treeIndex = determineBranch(
+        decodeTree,
+        current,
+        this.treeIndex + Math.max(1, valueLength),
+        char
+      );
+      if (this.treeIndex < 0) {
+        return this.result === 0 || // If we are parsing an attribute
+        this.decodeMode === 2 /* Attribute */ && // We shouldn't have consumed any characters after the entity,
+        (valueLength === 0 || // And there should be no invalid characters.
+        isEntityInAttributeInvalidEnd(char)) ? 0 : this.emitNotTerminatedNamedEntity();
+      }
+      current = decodeTree[this.treeIndex];
+      valueLength = (current & 49152 /* VALUE_LENGTH */) >> 14;
+      if (valueLength !== 0) {
+        if (char === 59 /* SEMI */) {
+          return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+        }
+        if (this.decodeMode !== 1 /* Strict */) {
+          this.result = this.treeIndex;
+          this.consumed += this.excess;
+          this.excess = 0;
+        }
+      }
+    }
+    return -1;
+  }
+  /**
+   * Emit a named entity that was not terminated with a semicolon.
+   *
+   * @returns The number of characters consumed.
+   */
+  emitNotTerminatedNamedEntity() {
+    const { result, decodeTree } = this;
+    const valueLength = (decodeTree[result] & 49152 /* VALUE_LENGTH */) >> 14;
+    this.emitNamedEntityData(result, valueLength, this.consumed);
+    this.errors?.missingSemicolonAfterCharacterReference();
+    return this.consumed;
+  }
+  /**
+   * Emit a named entity.
+   *
+   * @param result The index of the entity in the decode tree.
+   * @param valueLength The number of bytes in the entity.
+   * @param consumed The number of characters consumed.
+   *
+   * @returns The number of characters consumed.
+   */
+  emitNamedEntityData(result, valueLength, consumed) {
+    const { decodeTree } = this;
+    this.emitCodePoint(
+      valueLength === 1 ? decodeTree[result] & ~49152 /* VALUE_LENGTH */ : decodeTree[result + 1],
+      consumed
+    );
+    if (valueLength === 3) {
+      this.emitCodePoint(decodeTree[result + 2], consumed);
+    }
+    return consumed;
+  }
+  /**
+   * Signal to the parser that the end of the input was reached.
+   *
+   * Remaining data will be emitted and relevant errors will be produced.
+   *
+   * @returns The number of characters consumed.
+   */
+  end() {
+    switch (this.state) {
+      case 4 /* NamedEntity */: {
+        return this.result !== 0 && (this.decodeMode !== 2 /* Attribute */ || this.result === this.treeIndex) ? this.emitNotTerminatedNamedEntity() : 0;
+      }
+      // Otherwise, emit a numeric entity if we have one.
+      case 2 /* NumericDecimal */: {
+        return this.emitNumericEntity(0, 2);
+      }
+      case 3 /* NumericHex */: {
+        return this.emitNumericEntity(0, 3);
+      }
+      case 1 /* NumericStart */: {
+        this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);
+        return 0;
+      }
+      case 0 /* EntityStart */: {
+        return 0;
+      }
+    }
+  }
+}
+function getDecoder(decodeTree) {
+  let returnValue = "";
+  const decoder = new EntityDecoder(decodeTree, (data) => returnValue += fromCodePoint(data));
+  return function decodeWithTrie(input, decodeMode) {
+    let lastIndex = 0;
+    let offset = 0;
+    while ((offset = input.indexOf("&", offset)) >= 0) {
+      returnValue += input.slice(lastIndex, offset);
+      decoder.startEntity(decodeMode);
+      const length = decoder.write(
+        input,
+        // Skip the "&"
+        offset + 1
+      );
+      if (length < 0) {
+        lastIndex = offset + decoder.end();
+        break;
+      }
+      lastIndex = offset + length;
+      offset = length === 0 ? lastIndex + 1 : lastIndex;
+    }
+    const result = returnValue + input.slice(lastIndex);
+    returnValue = "";
+    return result;
+  };
+}
+function determineBranch(decodeTree, current, nodeIndex, char) {
+  const branchCount = (current & 16256 /* BRANCH_LENGTH */) >> 7;
+  const jumpOffset = current & 127 /* JUMP_TABLE */;
+  if (branchCount === 0) {
+    return jumpOffset !== 0 && char === jumpOffset ? nodeIndex : -1;
+  }
+  if (jumpOffset) {
+    const value = char - jumpOffset;
+    return value < 0 || value >= branchCount ? -1 : decodeTree[nodeIndex + value] - 1;
+  }
+  let lo = nodeIndex;
+  let hi = lo + branchCount - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    const midValue = decodeTree[mid];
+    if (midValue < char) {
+      lo = mid + 1;
+    } else if (midValue > char) {
+      hi = mid - 1;
+    } else {
+      return decodeTree[mid + branchCount];
+    }
+  }
+  return -1;
+}
+const htmlDecoder = /* @__PURE__ */ getDecoder(htmlDecodeTree);
+const xmlDecoder = /* @__PURE__ */ getDecoder(xmlDecodeTree);
+function decodeHTML(htmlString, mode = 0 /* Legacy */) {
+  return htmlDecoder(htmlString, mode);
+}
+function decodeHTMLAttribute(htmlAttribute) {
+  return htmlDecoder(htmlAttribute, 2 /* Attribute */);
+}
+function decodeHTMLStrict(htmlString) {
+  return htmlDecoder(htmlString, 1 /* Strict */);
+}
+function decodeXML(xmlString) {
+  return xmlDecoder(xmlString, 1 /* Strict */);
+}
+import { htmlDecodeTree as htmlDecodeTree2 } from "./decode-data-html.js";
+import { xmlDecodeTree as xmlDecodeTree2 } from "./decode-data-xml.js";
+import {
+  decodeCodePoint,
+  replaceCodePoint as replaceCodePoint2,
+  fromCodePoint as fromCodePoint2
+} from "./decode-codepoint.js";
+export {
+  BinTrieFlags,
+  DecodingMode,
+  EntityDecoder,
+  decodeCodePoint,
+  decodeHTML,
+  decodeHTMLAttribute,
+  decodeHTMLStrict,
+  decodeXML,
+  determineBranch,
+  fromCodePoint2 as fromCodePoint,
+  htmlDecodeTree2 as htmlDecodeTree,
+  replaceCodePoint2 as replaceCodePoint,
+  xmlDecodeTree2 as xmlDecodeTree
+};

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

@@ -0,0 +1,175 @@
+import { z } from 'astro/zod';
+export declare const authProviderSchema: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+    /**
+     * GitHub Auth Provider - Powered by Arctic
+     *
+     * Requires a GitHub OAuth App to be created and configured using ENV Variables
+     *
+     * @default false
+     */
+    github: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Discord Auth Provider - Powered by Arctic
+     *
+     * Requires a Discord OAuth App to be created and configured using ENV Variables
+     *
+     * @default false
+     */
+    discord: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Google Auth Provider - Powered by Arctic
+     *
+     * Requires a Google OAuth App to be created and configured using ENV Variables
+     *
+     * @default false
+     */
+    google: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Auth0 Auth Provider - Powered by Arctic
+     *
+     * Requires an Auth0 Application to be created and configured using ENV Variables
+     *
+     * @default false
+     */
+    auth0: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /**
+     * Username and Password Auth Provider
+     *
+     */
+    usernameAndPassword: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    usernameAndPasswordConfig: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        /**
+         * Allow User Registration - Allows users to register an account
+         *
+         * @default false
+         */
+        allowUserRegistration: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        allowUserRegistration: boolean;
+    }, {
+        allowUserRegistration?: boolean | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    github: boolean;
+    discord: boolean;
+    google: boolean;
+    auth0: boolean;
+    usernameAndPassword: boolean;
+    usernameAndPasswordConfig: {
+        allowUserRegistration: boolean;
+    };
+}, {
+    github?: boolean | undefined;
+    discord?: boolean | undefined;
+    google?: boolean | undefined;
+    auth0?: boolean | undefined;
+    usernameAndPassword?: boolean | undefined;
+    usernameAndPasswordConfig?: {
+        allowUserRegistration?: boolean | undefined;
+    } | undefined;
+}>>>;
+export type AuthProviders = z.infer<typeof authProviderSchema>;
+export declare const authConfigSchema: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+    /**
+     * Auth Providers - Allows enabling or disabling of the Authentication Providers
+     */
+    providers: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        /**
+         * GitHub Auth Provider - Powered by Arctic
+         *
+         * Requires a GitHub OAuth App to be created and configured using ENV Variables
+         *
+         * @default false
+         */
+        github: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Discord Auth Provider - Powered by Arctic
+         *
+         * Requires a Discord OAuth App to be created and configured using ENV Variables
+         *
+         * @default false
+         */
+        discord: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Google Auth Provider - Powered by Arctic
+         *
+         * Requires a Google OAuth App to be created and configured using ENV Variables
+         *
+         * @default false
+         */
+        google: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Auth0 Auth Provider - Powered by Arctic
+         *
+         * Requires an Auth0 Application to be created and configured using ENV Variables
+         *
+         * @default false
+         */
+        auth0: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /**
+         * Username and Password Auth Provider
+         *
+         */
+        usernameAndPassword: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        usernameAndPasswordConfig: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            /**
+             * Allow User Registration - Allows users to register an account
+             *
+             * @default false
+             */
+            allowUserRegistration: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            allowUserRegistration: boolean;
+        }, {
+            allowUserRegistration?: boolean | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        github: boolean;
+        discord: boolean;
+        google: boolean;
+        auth0: boolean;
+        usernameAndPassword: boolean;
+        usernameAndPasswordConfig: {
+            allowUserRegistration: boolean;
+        };
+    }, {
+        github?: boolean | undefined;
+        discord?: boolean | undefined;
+        google?: boolean | undefined;
+        auth0?: boolean | undefined;
+        usernameAndPassword?: boolean | undefined;
+        usernameAndPasswordConfig?: {
+            allowUserRegistration?: boolean | undefined;
+        } | undefined;
+    }>>>;
+    /**
+     * Auth Enabled - Allows enabling or disabling of the Authentication Configuration
+     *
+     * @default true
+     */
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    providers: {
+        github: boolean;
+        discord: boolean;
+        google: boolean;
+        auth0: boolean;
+        usernameAndPassword: boolean;
+        usernameAndPasswordConfig: {
+            allowUserRegistration: boolean;
+        };
+    };
+    enabled: boolean;
+}, {
+    providers?: {
+        github?: boolean | undefined;
+        discord?: boolean | undefined;
+        google?: boolean | undefined;
+        auth0?: boolean | undefined;
+        usernameAndPassword?: boolean | undefined;
+        usernameAndPasswordConfig?: {
+            allowUserRegistration?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+    enabled?: boolean | undefined;
+}>>>;

package/dist/schemas/config/auth.js

@@ -0,0 +1,65 @@
+import { z } from "astro/zod";
+const localUsernameAndPasswordConfig = z.object({
+  /**
+   * Allow User Registration - Allows users to register an account
+   *
+   * @default false
+   */
+  allowUserRegistration: z.boolean().optional().default(true)
+}).optional().default({});
+const authProviderSchema = z.object({
+  /**
+   * GitHub Auth Provider - Powered by Arctic
+   *
+   * Requires a GitHub OAuth App to be created and configured using ENV Variables
+   *
+   * @default false
+   */
+  github: z.boolean().optional().default(false),
+  /**
+   * Discord Auth Provider - Powered by Arctic
+   *
+   * Requires a Discord OAuth App to be created and configured using ENV Variables
+   *
+   * @default false
+   */
+  discord: z.boolean().optional().default(false),
+  /**
+   * Google Auth Provider - Powered by Arctic
+   *
+   * Requires a Google OAuth App to be created and configured using ENV Variables
+   *
+   * @default false
+   */
+  google: z.boolean().optional().default(false),
+  /**
+   * Auth0 Auth Provider - Powered by Arctic
+   *
+   * Requires an Auth0 Application to be created and configured using ENV Variables
+   *
+   * @default false
+   */
+  auth0: z.boolean().optional().default(false),
+  /**
+   * Username and Password Auth Provider
+   *
+   */
+  usernameAndPassword: z.boolean().optional().default(true),
+  usernameAndPasswordConfig: localUsernameAndPasswordConfig
+}).optional().default({});
+const authConfigSchema = z.object({
+  /**
+   * Auth Providers - Allows enabling or disabling of the Authentication Providers
+   */
+  providers: authProviderSchema,
+  /**
+   * Auth Enabled - Allows enabling or disabling of the Authentication Configuration
+   *
+   * @default true
+   */
+  enabled: z.boolean().optional().default(true)
+}).optional().default({});
+export {
+  authConfigSchema,
+  authProviderSchema
+};

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

@@ -0,0 +1,17 @@
+import { z } from 'astro/zod';
+export declare const overridesSchema: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+    /**
+     * Allows the user to override the default image component used in StudioCMS for rendering images.
+     */
+    CustomImageOverride: z.ZodOptional<z.ZodString>;
+    /**
+     * Allows the user to override the default formatted date component used in StudioCMS for rendering dates.
+     */
+    FormattedDateOverride: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    CustomImageOverride?: string | undefined;
+    FormattedDateOverride?: string | undefined;
+}, {
+    CustomImageOverride?: string | undefined;
+    FormattedDateOverride?: string | undefined;
+}>>>;

package/dist/schemas/config/componentoverrides.js

@@ -0,0 +1,14 @@
+import { z } from "astro/zod";
+const overridesSchema = z.object({
+  /**
+   * Allows the user to override the default image component used in StudioCMS for rendering images.
+   */
+  CustomImageOverride: z.string().optional(),
+  /**
+   * Allows the user to override the default formatted date component used in StudioCMS for rendering dates.
+   */
+  FormattedDateOverride: z.string().optional()
+}).optional().default({});
+export {
+  overridesSchema
+};