/*!
 * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
 * Licensed under the MIT License.
 */
import { type ArrayNodeCustomizableSchema, type MapNodeCustomizableSchema, type ObjectNodeSchema } from "../node-kinds/index.js";
import { SchemaFactory, type SchemaFactoryObjectOptions, type ScopedSchemaName } from "./schemaFactory.js";
import type { ImplicitAllowedTypes, ImplicitAnnotatedAllowedTypes, ImplicitAnnotatedFieldSchema, NodeSchemaOptionsAlpha } from "../schemaTypes.js";
import type { RestrictiveStringRecord } from "../../util/index.js";
import type { NodeKind, TreeNodeSchemaClass } from "../core/index.js";
import type { ArrayNodeCustomizableSchemaUnsafe, MapNodeCustomizableSchemaUnsafe, System_Unsafe } from "./typesUnsafe.js";
import type { SimpleObjectNodeSchema } from "../simpleSchema.js";
/**
 * {@link SchemaFactory} with additional alpha APIs.
 *
 * @alpha
 * @privateRemarks
 *
 * Some private methods on `SchemaFactory` are intentionally duplicated here to avoid increasing their exposure to `protected`.
 * If we were to do so, they would be exposed on the public API surface of `SchemaFactory`.
 */
export declare class SchemaFactoryAlpha<out TScope extends string | undefined = string | undefined, TName extends number | string = string> extends SchemaFactory<TScope, TName> {
    private scoped2;
    /**
     * Define a {@link TreeNodeSchemaClass} for a {@link TreeObjectNode}.
     *
     * @param name - Unique identifier for this schema within this factory's scope.
     * @param fields - Schema for fields of the object node's schema. Defines what children can be placed under each key.
     * @param options - Additional options for the schema.
     */
    objectAlpha<const Name extends TName, const T extends RestrictiveStringRecord<ImplicitAnnotatedFieldSchema>, const TCustomMetadata = unknown>(name: Name, fields: T, options?: SchemaFactoryObjectOptions<TCustomMetadata>): ObjectNodeSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata> & {
        /**
         * Typing checking workaround: not for for actual use.
         * @remarks
         * This API collides with {@link TreeNodeSchemaCore.createFromInsertable} to disable a type checking optimization which produces different and undesired results.
         * See {@link https://github.com/microsoft/TypeScript/issues/59049#issuecomment-2773459693} for more details.
         * @privateRemarks
         * The specific issue here is non-empty POJO mode object schema not being assignable to `ObjectNodeSchema`,
         * See the above link and the tests in objectNode.spec.ts which reference it.
         * @system
         */
        readonly createFromInsertable: unknown;
    };
    /**
     * {@inheritdoc SchemaFactory.objectRecursive}
     */
    objectRecursive<const Name extends TName, const T extends RestrictiveStringRecord<System_Unsafe.ImplicitFieldSchemaUnsafe>, const TCustomMetadata = unknown>(name: Name, t: T, options?: SchemaFactoryObjectOptions<TCustomMetadata>): TreeNodeSchemaClass<ScopedSchemaName<TScope, Name>, NodeKind.Object, System_Unsafe.TreeObjectNodeUnsafe<T, ScopedSchemaName<TScope, Name>>, object & System_Unsafe.InsertableObjectFromSchemaRecordUnsafe<T>, false, T, never, TCustomMetadata> & SimpleObjectNodeSchema<TCustomMetadata> & Pick<ObjectNodeSchema, "fields">;
    /**
     * {@inheritDoc SchemaStatics.leaves}
     */
    static readonly leaves: readonly [import("../leafNodeSchema.js").LeafSchema<"string", string> & import("../simpleSchema.js").SimpleLeafNodeSchema, import("../leafNodeSchema.js").LeafSchema<"number", number> & import("../simpleSchema.js").SimpleLeafNodeSchema, import("../leafNodeSchema.js").LeafSchema<"boolean", boolean> & import("../simpleSchema.js").SimpleLeafNodeSchema, import("../leafNodeSchema.js").LeafSchema<"null", null> & import("../simpleSchema.js").SimpleLeafNodeSchema, import("../leafNodeSchema.js").LeafSchema<"handle", import("@fluidframework/core-interfaces").IFluidHandle<unknown>> & import("../simpleSchema.js").SimpleLeafNodeSchema];
    /**
     * {@inheritDoc SchemaStatics.optional}
     */
    static readonly optional: {
        <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<import("../schemaTypes.js").FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined): import("../schemaTypes.js").FieldSchemaAlpha<import("../schemaTypes.js").FieldKind.Optional, T, TCustomMetadata>;
        <const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<import("../schemaTypes.js").FieldPropsAlpha<TCustomMetadata_1>, "defaultProvider"> | undefined): import("../schemaTypes.js").FieldSchemaAlpha<import("../schemaTypes.js").FieldKind.Optional, import("../schemaTypes.js").UnannotateImplicitAllowedTypes<T_1>, TCustomMetadata_1>;
    };
    /**
     * {@inheritDoc SchemaStatics.required}
     */
    static readonly required: {
        <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<import("../schemaTypes.js").FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined): import("../schemaTypes.js").FieldSchemaAlpha<import("../schemaTypes.js").FieldKind.Required, T, TCustomMetadata>;
        <const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<import("../schemaTypes.js").FieldPropsAlpha<TCustomMetadata_1>, "defaultProvider"> | undefined): import("../schemaTypes.js").FieldSchemaAlpha<import("../schemaTypes.js").FieldKind.Required, import("../schemaTypes.js").UnannotateImplicitAllowedTypes<T_1>, TCustomMetadata_1>;
    };
    /**
     * {@inheritDoc SchemaStatics.optionalRecursive}
     */
    static readonly optionalRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<import("../schemaTypes.js").FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined) => import("./typesUnsafe.js").FieldSchemaAlphaUnsafe<import("../schemaTypes.js").FieldKind.Optional, T, TCustomMetadata>;
    /**
     * {@inheritDoc SchemaStatics.requiredRecursive}
     */
    static readonly requiredRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<import("../schemaTypes.js").FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined) => import("./typesUnsafe.js").FieldSchemaAlphaUnsafe<import("../schemaTypes.js").FieldKind.Required, T, TCustomMetadata>;
    /**
     * Like {@link SchemaFactory.identifier} but static and a factory function that can be provided {@link FieldProps}.
     */
    static readonly identifier: <const TCustomMetadata = unknown>(props?: Omit<import("../schemaTypes.js").FieldProps<TCustomMetadata>, "defaultProvider"> | undefined) => import("../schemaTypes.js").FieldSchemaAlpha<import("../schemaTypes.js").FieldKind.Identifier, import("../leafNodeSchema.js").LeafSchema<"string", string> & import("../simpleSchema.js").SimpleLeafNodeSchema, TCustomMetadata>;
    /**
     * {@inheritDoc SchemaStatics.leaves}
     */
    readonly leaves: readonly [import("../leafNodeSchema.js").LeafSchema<"string", string> & import("../simpleSchema.js").SimpleLeafNodeSchema, import("../leafNodeSchema.js").LeafSchema<"number", number> & import("../simpleSchema.js").SimpleLeafNodeSchema, import("../leafNodeSchema.js").LeafSchema<"boolean", boolean> & import("../simpleSchema.js").SimpleLeafNodeSchema, import("../leafNodeSchema.js").LeafSchema<"null", null> & import("../simpleSchema.js").SimpleLeafNodeSchema, import("../leafNodeSchema.js").LeafSchema<"handle", import("@fluidframework/core-interfaces").IFluidHandle<unknown>> & import("../simpleSchema.js").SimpleLeafNodeSchema];
    /**
     * {@inheritDoc SchemaStatics.optional}
     */
    readonly optional: {
        <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<import("../schemaTypes.js").FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined): import("../schemaTypes.js").FieldSchemaAlpha<import("../schemaTypes.js").FieldKind.Optional, T, TCustomMetadata>;
        <const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<import("../schemaTypes.js").FieldPropsAlpha<TCustomMetadata_1>, "defaultProvider"> | undefined): import("../schemaTypes.js").FieldSchemaAlpha<import("../schemaTypes.js").FieldKind.Optional, import("../schemaTypes.js").UnannotateImplicitAllowedTypes<T_1>, TCustomMetadata_1>;
    };
    /**
     * {@inheritDoc SchemaStatics.required}
     */
    readonly required: {
        <const T extends ImplicitAllowedTypes, const TCustomMetadata = unknown>(t: T, props?: Omit<import("../schemaTypes.js").FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined): import("../schemaTypes.js").FieldSchemaAlpha<import("../schemaTypes.js").FieldKind.Required, T, TCustomMetadata>;
        <const T_1 extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata_1 = unknown>(t: T_1, props?: Omit<import("../schemaTypes.js").FieldPropsAlpha<TCustomMetadata_1>, "defaultProvider"> | undefined): import("../schemaTypes.js").FieldSchemaAlpha<import("../schemaTypes.js").FieldKind.Required, import("../schemaTypes.js").UnannotateImplicitAllowedTypes<T_1>, TCustomMetadata_1>;
    };
    /**
     * {@inheritDoc SchemaStatics.optionalRecursive}
     */
    readonly optionalRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<import("../schemaTypes.js").FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined) => import("./typesUnsafe.js").FieldSchemaAlphaUnsafe<import("../schemaTypes.js").FieldKind.Optional, T, TCustomMetadata>;
    /**
     * {@inheritDoc SchemaStatics.requiredRecursive}
     */
    readonly requiredRecursive: <const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(t: T, props?: Omit<import("../schemaTypes.js").FieldPropsAlpha<TCustomMetadata>, "defaultProvider"> | undefined) => import("./typesUnsafe.js").FieldSchemaAlphaUnsafe<import("../schemaTypes.js").FieldKind.Required, T, TCustomMetadata>;
    /**
     * Define a {@link TreeNodeSchema} for a {@link TreeMapNode}.
     *
     * @param name - Unique identifier for this schema within this factory's scope.
     * @param allowedTypes - The types that may appear as values in the map.
     * @param options - Additional options for the schema.
     *
     * @example
     * ```typescript
     * class NamedMap extends factory.map("name", factory.number, {
     * 	metadata: { description: "A map of numbers" }
     * }) {}
     * ```
     */
    mapAlpha<Name extends TName, const T extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): MapNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata>;
    /**
     * {@inheritDoc SchemaFactory.objectRecursive}
     */
    mapRecursive<Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): MapNodeCustomizableSchemaUnsafe<ScopedSchemaName<TScope, Name>, T, TCustomMetadata>;
    /**
     * Define (and add to this library) a {@link TreeNodeSchemaClass} for a {@link (TreeArrayNode:interface)}.
     *
     * @param name - Unique identifier for this schema within this factory's scope.
     * @param allowedTypes - The types that may appear in the array.
     * @param options - Additional options for the schema.
     *
     * @example
     * ```typescript
     * class NamedArray extends factory.arrayAlpha("name", factory.number) {}
     * ```
     */
    arrayAlpha<const Name extends TName, const T extends ImplicitAnnotatedAllowedTypes, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): ArrayNodeCustomizableSchema<ScopedSchemaName<TScope, Name>, T, true, TCustomMetadata>;
    /**
     * {@inheritDoc SchemaFactory.objectRecursive}
     */
    arrayRecursive<const Name extends TName, const T extends System_Unsafe.ImplicitAllowedTypesUnsafe, const TCustomMetadata = unknown>(name: Name, allowedTypes: T, options?: NodeSchemaOptionsAlpha<TCustomMetadata>): ArrayNodeCustomizableSchemaUnsafe<ScopedSchemaName<TScope, Name>, T, TCustomMetadata>;
    /**
     * Create a {@link SchemaFactory} with a {@link SchemaFactory.scope|scope} which is a combination of this factory's scope and the provided name.
     * @remarks
     * The main use-case for this is when creating a collection of related schema (for example using a function that creates multiple schema).
     * Creating such related schema using a sub-scope helps ensure they won't collide with other schema in the parent scope.
     */
    scopedFactory<const T extends TName, TNameInner extends number | string = string>(name: T): SchemaFactoryAlpha<ScopedSchemaName<TScope, T>, TNameInner>;
}
//# sourceMappingURL=schemaFactoryAlpha.d.ts.map