@microsoft/kiota/dist/cjs/types/types.d.ts

npm package exposing Kiota CLI functionality to TypeScript

export declare enum KiotaGenerationLanguage {
    CSharp = 0,
    Java = 1,
    TypeScript = 2,
    PHP = 3,
    Python = 4,
    Go = 5,
    Swift = 6,
    Ruby = 7,
    CLI = 8,
    Dart = 9
}
export declare enum KiotaPluginType {
    OpenAI = 0,
    ApiManifest = 1,
    ApiPlugin = 2
}
export interface KiotaLogEntry {
    level: LogLevel;
    message: string;
}
export declare enum OpenApiAuthType {
    None = 0,
    ApiKey = 1,
    Http = 2,
    OAuth2 = 3,
    OpenIdConnect = 4
}
export interface SecurityRequirementObject {
    [name: string]: string[];
}
export interface KiotaOpenApiNode {
    segment: string;
    path: string;
    children: KiotaOpenApiNode[];
    operationId?: string;
    summary?: string;
    description?: string;
    selected?: boolean;
    isOperation?: boolean;
    documentationUrl?: string;
    clientNameOrPluginName?: string;
    authType?: OpenApiAuthType;
    logs?: KiotaLogEntry[];
    servers?: string[];
    security?: SecurityRequirementObject[];
    adaptiveCard?: AdaptiveCardInfo;
}
export interface AdaptiveCardInfo {
    dataPath: string;
    file: string;
}
export interface CacheClearableConfiguration {
    clearCache: boolean;
}
export interface KiotaShowConfiguration extends CacheClearableConfiguration {
    includeFilters: string[];
    excludeFilters: string[];
    descriptionPath: string;
    includeKiotaValidationRules: boolean;
}
export interface KiotaGetManifestDetailsConfiguration extends CacheClearableConfiguration {
    manifestPath: string;
    apiIdentifier: string;
}
export interface KiotaLoggedResult {
    logs: KiotaLogEntry[];
}
export declare enum OpenApiSpecVersion {
    V2_0 = 0,
    V3_0 = 1,
    V3_1 = 2
}
export interface KiotaTreeResult extends KiotaLoggedResult {
    specVersion: OpenApiSpecVersion;
    rootNode?: KiotaOpenApiNode;
    apiTitle?: string;
    servers?: string[];
    security?: SecurityRequirementObject[];
    securitySchemes?: {
        [key: string]: SecuritySchemeObject;
    };
}
export interface KiotaManifestResult extends KiotaLoggedResult {
    apiDescriptionPath?: string;
    selectedPaths?: string[];
}
export interface KiotaSearchResult extends KiotaLoggedResult {
    results: Record<string, KiotaSearchResultItem>;
}
export interface KiotaSearchResultItem {
    Title: string;
    Description: string;
    ServiceUrl?: string;
    DescriptionUrl?: string;
    VersionLabels?: string[];
}
export declare enum ConsumerOperation {
    Add = 0,
    Edit = 1,
    Remove = 2,
    Generate = 3
}
export declare function generationLanguageToString(language: KiotaGenerationLanguage): string;
export declare const allGenerationLanguages: KiotaGenerationLanguage[];
/**
 * The log level from Kiota
 * @see https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-7.0
 */
export declare enum LogLevel {
    trace = 0,
    debug = 1,
    information = 2,
    warning = 3,
    error = 4,
    critical = 5,
    none = 6
}
export interface LanguageInformation {
    MaturityLevel: MaturityLevel;
    Dependencies: LanguageDependency[];
    DependencyInstallCommand: string;
    ClientNamespaceName: string;
    ClientClassName: string;
    StructuredMimeTypes: string[];
}
export interface LanguageDependency {
    Name: string;
    Version: string;
    DependencyType: DependencyType;
}
export declare enum MaturityLevel {
    experimental = 0,
    preview = 1,
    stable = 2
}
export declare enum DependencyType {
    abstractions = 0,
    serialization = 1,
    authentication = 2,
    http = 3,
    bundle = 4,
    additional = 5
}
export interface ConfigurationFile {
    version: string;
    clients: Record<string, ClientObjectProperties>;
    plugins: Record<string, PluginObjectProperties>;
}
export interface GenerationConfiguration {
    cleanOutput: boolean;
    clearCache: boolean;
    clientClassName: string;
    clientNamespaceName: string;
    deserializers: string[];
    disabledValidationRules: string[];
    excludeBackwardCompatible: boolean;
    excludePatterns: string[];
    includeAdditionalData: boolean;
    includePatterns: string[];
    language: KiotaGenerationLanguage;
    openAPIFilePath: string;
    outputPath: string;
    serializers: string[];
    structuredMimeTypes: string[];
    usesBackingStore: boolean;
    pluginTypes: KiotaPluginType[];
    operation: ConsumerOperation;
    noWorkspace?: boolean;
    pluginAuthRefid?: string;
    pluginAuthType?: PluginAuthType | null;
}
export declare enum PluginAuthType {
    oAuthPluginVault = "OAuthPluginVault",
    apiKeyPluginVault = "ApiKeyPluginVault"
}
export interface WorkspaceObjectProperties {
    descriptionLocation: string;
    includePatterns: string[];
    excludePatterns: string[];
    outputPath: string;
}
export interface ClientObjectProperties extends WorkspaceObjectProperties {
    language: string;
    structuredMimeTypes: string[];
    clientNamespaceName: string;
    usesBackingStore: boolean;
    includeAdditionalData: boolean;
    excludeBackwardCompatible: boolean;
    disabledValidationRules: string[];
}
export interface PluginObjectProperties extends WorkspaceObjectProperties {
    types: string[];
    authType?: PluginAuthType;
    authReferenceId?: string;
}
export type ClientOrPluginProperties = ClientObjectProperties | PluginObjectProperties;
export interface LanguagesInformation {
    [key: string]: LanguageInformation;
}
export interface KiotaResult extends KiotaLoggedResult {
    isSuccess: boolean;
}
export interface ValidateOpenApiResult extends KiotaLoggedResult {
}
export interface GeneratePluginResult extends KiotaResult {
    aiPlugin: string;
    openAPISpec: string;
}
export interface PluginManifestResult extends KiotaResult {
    isValid: boolean;
    schema_version: string;
    name_for_human: string;
    functions: PluginFunction[];
    runtime: PluginRuntime[];
}
export interface PluginFunction {
    name: string;
    description: string;
}
export interface PluginAuth {
    type: string;
    reference_id?: string;
}
export interface PluginRuntime {
    type: string;
    auth: PluginAuth;
    run_for_functions: string[];
}
export type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
export interface AuthReferenceId {
    referenceId: string;
}
export interface HttpSecurityScheme extends AuthReferenceId {
    type: 'http';
    description?: string;
    scheme: string;
    bearerFormat?: string;
}
export interface ApiKeySecurityScheme extends AuthReferenceId {
    type: 'apiKey';
    description?: string;
    name: string;
    in: string;
}
export interface OAuth2SecurityScheme extends AuthReferenceId {
    type: 'oauth2';
    description?: string;
    flows: {
        implicit?: {
            authorizationUrl: string;
            refreshUrl?: string;
            scopes: {
                [scope: string]: string;
            };
        };
        password?: {
            tokenUrl: string;
            refreshUrl?: string;
            scopes: {
                [scope: string]: string;
            };
        };
        clientCredentials?: {
            tokenUrl: string;
            refreshUrl?: string;
            scopes: {
                [scope: string]: string;
            };
        };
        authorizationCode?: {
            authorizationUrl: string;
            tokenUrl: string;
            refreshUrl?: string;
            scopes: {
                [scope: string]: string;
            };
        };
    };
}
export interface OpenIdSecurityScheme extends AuthReferenceId {
    type: 'openIdConnect';
    description?: string;
    openIdConnectUrl: string;
}