@autorest/powershell/dist/utils/schema.d.ts

AutoRest PowerShell Cmdlet Generator

import { ImplementationDetails } from './components';
import { Extensions } from './extensions';
import { DeepPartial } from '@azure-tools/codegen';
import { Dictionary } from '@azure-tools/linq';
import { Schema, ObjectSchema, Property } from '@autorest/codemodel';
import { EnhancedTypeDeclaration } from '../llcsharp/schema/extended-type-declaration';
import { ModelClass } from '../llcsharp/model/model-class';
import { ModelInterface } from '../llcsharp/model/interface';
export interface PropertyDetails extends ImplementationDetails {
    required: boolean;
    readOnly: 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 Mutability {
    create: boolean;
    update: boolean;
    read: boolean;
}
export interface VirtualProperty {
    /** The property that this represents */
    property: Property;
    /** The things that went into building the name */
    nameComponents: Array<string>;
    /** Names To use in priority order */
    nameOptions: Array<string>;
    /** the name of this virtual property */
    name: string;
    /** the member that should be called to get to the virtual property. (may be recursive) */
    accessViaProperty?: VirtualProperty;
    accessViaMember?: VirtualProperty;
    /** the member's schema */
    accessViaSchema?: Schema;
    originalContainingSchema: Schema;
    private?: boolean;
    alias: Array<string>;
    description: string;
    format?: PropertyFormat;
    required: boolean;
    readOnly?: boolean;
    sharedWith?: Array<VirtualProperty>;
    read?: boolean;
    update?: boolean;
    create?: boolean;
    serializedName?: string;
}
export interface PropertyFormat {
    suppressFormat?: boolean;
    index?: number;
    width?: number;
    label?: string;
}
export interface VirtualProperties {
    owned: Array<VirtualProperty>;
    inherited: Array<VirtualProperty>;
    inlined: Array<VirtualProperty>;
}
export interface SchemaDetails extends ImplementationDetails {
    /** namespace of the implementation of this item */
    namespace?: string;
    enum?: EnumDetails;
    purpose?: Purpose;
    virtualProperties?: VirtualProperties;
    /** if this is a child of a polymorphic class, this will have the value of the descriminator.  */
    discriminatorValue?: string;
    suppressFormat?: boolean;
    typeDeclaration?: EnhancedTypeDeclaration;
    classImplementation?: ModelClass;
    interfaceImplementation?: ModelInterface;
    internalInterfaceImplementation?: ModelInterface;
    interfaceName?: string;
    internalInterfaceName?: string;
    fullInternalInterfaceName?: string;
    fullname?: string;
}
export declare function getPolymorphicBases(schema: ObjectSchema): Array<Schema>;
export declare function getAllProperties(schema: Schema): Array<Property>;
export declare function getAllPublicVirtualProperties(virtualProperties?: VirtualProperties): Array<VirtualProperty>;
export declare function getAllPublicVirtualPropertiesForSdk(virtualProperties?: VirtualProperties): Array<VirtualProperty>;
export declare function getAllPublicVirtualPropertiesForSdkWithoutInherited(virtualProperties?: VirtualProperties): Array<VirtualProperty>;
export declare function getAllVirtualProperties(virtualProperties?: VirtualProperties): Array<VirtualProperty>;
export declare function getVirtualPropertyFromPropertyName(virtualProperties: VirtualProperties | undefined, propertyName: string): VirtualProperty | undefined;
export declare class Discriminator extends Extensions implements Discriminator {
    propertyName: string;
    extensions: Dictionary<any>;
    mapping: Dictionary<string>;
    constructor(propertyName: string, initializer?: DeepPartial<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?: DeepPartial<XML>);
}
export interface XML extends Extensions {
    name?: string;
    namespace?: string;
    prefix?: string;
    attribute: boolean;
    wrapped: boolean;
}
export declare function getMutability(property: Property): Mutability;
export declare function valueType(type: string): boolean;
//# sourceMappingURL=schema.d.ts.map