@microsoft.azure/autorest.incubator/dist/common/code-model/schema.d.ts

AutoRest incubator project

import { ImplementationDetails, ExternalDocumentation, LanguageDetails } from '#common/code-model/components';
import { Extensions } from '#common/code-model/extensions';
import { Dictionary } from '#common/dictionary';
import { DeepPartial } from '#common/initializer';
export interface PropertyDetails extends ImplementationDetails {
    required: boolean;
}
export interface EnumValue {
    value: any;
    description: string;
    name: string;
}
export interface EnumDetails {
    modelAsString: boolean;
    values: Array<EnumValue>;
    name: string;
}
export declare enum Purpose {
    Header = "Header"
}
export interface SchemaDetails extends ImplementationDetails {
    /** namespace of the implementation of this item */
    namespace?: string;
    enum?: EnumDetails;
    purpose?: Purpose;
}
export declare class Schema extends Extensions implements Schema {
    details: LanguageDetails<SchemaDetails>;
    required: string[];
    enum: any[];
    allOf: Schema[];
    oneOf: Schema[];
    anyOf: Schema[];
    properties: Dictionary<Property>;
    extensions: Dictionary<any>;
    constructor(name: string, initializer?: DeepPartial<Schema>);
}
export declare function getPolymorphicBases(schema: Schema): Array<Schema>;
export declare function getAllProperties(schema: Schema): Array<Property>;
export interface Property extends Extensions {
    details: LanguageDetails<PropertyDetails>;
    /** description can be on the property reference, so that properties can have a description different from the type description. */
    description?: string;
    schema: Schema;
}
export declare class Property extends Extensions implements Property {
    serializedName: string;
    details: LanguageDetails<PropertyDetails>;
    extensions: Dictionary<any>;
    constructor(name: string, initializer?: Partial<Property>);
}
export declare class Discriminator extends Extensions implements Discriminator {
    propertyName: string;
    extensions: Dictionary<any>;
    mapping: Dictionary<string>;
    constructor(propertyName: string, initializer?: Partial<Discriminator>);
}
export interface Discriminator extends Extensions {
    propertyName: string;
    mapping: Dictionary<string>;
}
export declare enum JsonType {
    Array = "array",
    Boolean = "boolean",
    Integer = "integer",
    Number = "number",
    Object = "object",
    String = "string"
}
export declare function isJsonType(type: JsonType, schema?: Schema): schema is Schema;
export declare function isSchemaObject(schema?: Schema): schema is Schema;
export declare class XML extends Extensions implements XML {
    extensions: Dictionary<any>;
    attribute: boolean;
    wrapped: boolean;
    constructor(initializer?: Partial<XML>);
}
export interface XML extends Extensions {
    name?: string;
    namespace?: string;
    prefix?: string;
    attribute: boolean;
    wrapped: boolean;
}
export interface Schema extends Extensions {
    details: LanguageDetails<SchemaDetails>;
    type?: JsonType;
    title?: string;
    description?: string;
    format?: string;
    nullable: boolean;
    readOnly: boolean;
    writeOnly: boolean;
    deprecated: boolean;
    required: Array<string>;
    multipleOf?: number;
    maximum?: number;
    exclusiveMaximum?: boolean;
    minimum?: number;
    exclusiveMinimum?: boolean;
    maxLength?: number;
    minLength?: number;
    pattern?: string;
    maxItems?: number;
    minItems?: number;
    uniqueItems?: boolean;
    maxProperties?: number;
    minProperties?: number;
    example?: any;
    default?: any;
    discriminator?: Discriminator;
    externalDocs?: ExternalDocumentation;
    xml?: XML;
    enum: Array<any>;
    not?: Schema;
    allOf: Array<Schema>;
    oneOf: Array<Schema>;
    anyOf: Array<Schema>;
    items?: Schema;
    properties: Dictionary<Property>;
    additionalProperties?: boolean | Schema;
}
//# sourceMappingURL=schema.d.ts.map