@scalar/oas-utils 0.2.43 → 0.2.45

package/dist/migrations/v-2.1.0/migration.d.ts

@@ -0,0 +1,334 @@
+import type { v_0_0_0 } from '../../migrations/v-0.0.0/types.generated';
+/** V-0.0.0 to V-2.1.0 migration */
+export declare const migrate_v_2_1_0: (data: Omit<v_0_0_0.Data, "folders">) => {
+    collections: {
+        type: "collection";
+        openapi: string;
+        info: {
+            title: string;
+            summary?: string | undefined;
+            description?: string | undefined;
+            termsOfService?: string | undefined;
+            contact?: {
+                name?: string | undefined;
+                url?: string | undefined;
+                email?: string | undefined;
+            } | undefined;
+            license?: {
+                name: string;
+                identifier?: string | undefined;
+                url?: string | undefined;
+            } | undefined;
+            version: string;
+        };
+        security: {
+            [x: string]: string[];
+        }[];
+        externalDocs: {
+            description: string;
+            url: string;
+        } | undefined;
+        uid: string;
+        securitySchemes: string[];
+        selectedServerUid: string;
+        servers: string[];
+        requests: string[];
+        tags: string[];
+        auth: Record<string, {
+            type: "apiKey";
+            value: string;
+            name: string;
+        } | {
+            type: "http";
+            username: string;
+            password: string;
+            token: string;
+        } | {
+            type: "oauth-implicit";
+            token: string;
+        } | {
+            type: "oauth-password";
+            username: string;
+            password: string;
+            token: string;
+            clientSecret: string;
+        } | {
+            type: "oauth-clientCredentials";
+            token: string;
+            clientSecret: string;
+        } | {
+            type: "oauth-authorizationCode";
+            token: string;
+            clientSecret: string;
+        }>;
+        children: string[];
+    }[];
+    cookies: v_0_0_0.Cookie[];
+    environments: {
+        value: string;
+        uid: string;
+        name: string;
+        color: string;
+        raw?: string;
+        parsed?: {
+            key: string;
+            value: string;
+        }[];
+        isDefault?: boolean | undefined;
+    }[];
+    requestExamples: {
+        type: "requestExample";
+        uid: string;
+        url?: string;
+        requestUid: string;
+        name: string;
+        body: {
+            raw?: {
+                encoding: "json" | "text" | "html" | "text" | "javascript" | "xml" | "yaml" | "edn";
+                value: string;
+            };
+            formData?: {
+                encoding: "form-data" | "urlencoded";
+                value: {
+                    key: string;
+                    value: string;
+                    enabled: boolean;
+                    file?: {
+                        name: string;
+                        lastModified: number;
+                        webkitRelativePath: string;
+                        size: number;
+                        type: string;
+                        arrayBuffer: (...args_0: unknown[]) => Promise<any>;
+                        slice: (args_0: number | undefined, args_1: number | undefined, args_2: string | undefined, ...args_3: unknown[]) => any;
+                        stream: (...args_0: unknown[]) => any;
+                        text: (...args_0: unknown[]) => Promise<string>;
+                    } | undefined;
+                    description?: string | undefined;
+                    refUid?: string | undefined;
+                    required?: boolean | undefined;
+                    enum?: string[] | undefined;
+                    type?: string | undefined;
+                    format?: string | undefined;
+                    minimum?: number | undefined;
+                    maximum?: number | undefined;
+                    default?: any | undefined;
+                    nullable?: boolean | undefined;
+                }[];
+            };
+            binary?: any | undefined;
+            activeBody: "raw" | "formData" | "binary";
+        };
+        parameters: {
+            path: {
+                key: string;
+                value: string;
+                enabled: boolean;
+                file?: any | undefined;
+                description?: string | undefined;
+                refUid?: string | undefined;
+                required?: boolean | undefined;
+                enum?: string[] | undefined;
+                type?: string | undefined;
+                format?: string | undefined;
+                minimum?: number | undefined;
+                maximum?: number | undefined;
+                default?: any | undefined;
+                nullable?: boolean | undefined;
+            }[];
+            query: {
+                key: string;
+                value: string;
+                enabled: boolean;
+                file?: any | undefined;
+                description?: string | undefined;
+                refUid?: string | undefined;
+                required?: boolean | undefined;
+                enum?: string[] | undefined;
+                type?: string | undefined;
+                format?: string | undefined;
+                minimum?: number | undefined;
+                maximum?: number | undefined;
+                default?: any | undefined;
+                nullable?: boolean | undefined;
+            }[];
+            headers: {
+                key: string;
+                value: string;
+                enabled: boolean;
+                file?: any | undefined;
+                description?: string | undefined;
+                refUid?: string | undefined;
+                required?: boolean | undefined;
+                enum?: string[] | undefined;
+                type?: string | undefined;
+                format?: string | undefined;
+                minimum?: number | undefined;
+                maximum?: number | undefined;
+                default?: any | undefined;
+                nullable?: boolean | undefined;
+            }[];
+            cookies: {
+                key: string;
+                value: string;
+                enabled: boolean;
+                file?: any | undefined;
+                description?: string | undefined;
+                refUid?: string | undefined;
+                required?: boolean | undefined;
+                enum?: string[] | undefined;
+                type?: string | undefined;
+                format?: string | undefined;
+                minimum?: number | undefined;
+                maximum?: number | undefined;
+                default?: any | undefined;
+                nullable?: boolean | undefined;
+            }[];
+        };
+        auth?: {
+            [x: string]: any;
+        };
+    }[];
+    requests: {
+        parameters: {
+            required: boolean;
+            name: string;
+            in: "path" | "query" | "header" | "cookie";
+            deprecated: boolean;
+            description?: string | undefined;
+            schema?: unknown;
+            content?: unknown;
+            style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+        }[];
+        type: "request";
+        method: "options" | "delete" | "get" | "connect" | "head" | "patch" | "post" | "put" | "trace";
+        examples: string[];
+        selectedSecuritySchemeUids: string[];
+        selectedServerUid: string;
+        servers: never[];
+        path: string;
+        uid: string;
+        ref?: {
+            path: string;
+            collectionRef?: string | undefined;
+            isExternal: boolean;
+        } | null;
+        tags?: string[] | undefined;
+        summary?: string | undefined;
+        description?: string | undefined;
+        operationId?: string | undefined;
+        security?: {
+            [x: string]: string[];
+        }[] | undefined;
+        securitySchemeUids?: string[];
+        requestBody?: any | undefined;
+        childUids?: string[];
+        history?: any[];
+    }[];
+    securitySchemes: ({
+        nameKey: string;
+        'x-scalar-client-id': string;
+        flow: {
+            type: "implicit";
+            refreshUrl: string;
+            scopes: Map<string, string | undefined> | Record<string, string | undefined> | {};
+            selectedScopes: string[];
+            authorizationUrl: string;
+            'x-scalar-redirect-uri': string;
+        } | {
+            type: "password";
+            refreshUrl: string;
+            scopes: Map<string, string | undefined> | Record<string, string | undefined> | {};
+            selectedScopes: string[];
+            tokenUrl: string;
+        } | {
+            type: "clientCredentials";
+            refreshUrl: string;
+            scopes: Map<string, string | undefined> | Record<string, string | undefined> | {};
+            selectedScopes: string[];
+            tokenUrl: string;
+        } | {
+            type: "authorizationCode";
+            refreshUrl: string;
+            scopes: Map<string, string | undefined> | Record<string, string | undefined> | {};
+            selectedScopes: string[];
+            authorizationUrl: string;
+            'x-scalar-redirect-uri': string;
+            tokenUrl: string;
+        };
+        uid: string;
+        description?: string | undefined;
+        type: "oauth2";
+        clientId?: string;
+    } | {
+        nameKey: string;
+        uid: string;
+        description?: string | undefined;
+        type: "apiKey";
+        name: string;
+        in: "query" | "header" | "cookie";
+        value?: string;
+    } | {
+        nameKey: string;
+        uid: string;
+        description?: string | undefined;
+        type: "http";
+        scheme: "basic" | "bearer";
+        bearerFormat: "JWT" | string;
+        value?: string;
+        secondValue?: string;
+    } | {
+        nameKey: string;
+        uid: string;
+        description?: string | undefined;
+        type: "openIdConnect";
+        openIdConnectUrl: string;
+    })[];
+    servers: {
+        variables: {
+            [x: string]: {
+                uid?: string;
+                enum?: [string, ...string[]] | undefined;
+                default?: string;
+                description?: string | undefined;
+                value?: string | undefined;
+            };
+        };
+        uid: string;
+        url: string;
+        description?: string | undefined;
+    }[];
+    tags: {
+        type: "tag";
+        uid: string;
+        name: string;
+        description: string | undefined;
+        children: string[];
+        'x-scalar-children': never[];
+    }[];
+    workspaces: {
+        description: string;
+        cookies: string[];
+        collections: string[];
+        environments: string[];
+        uid: string;
+        name: string;
+        isReadOnly: boolean;
+        collectionUids?: string[];
+        environmentUids?: string[];
+        hotKeyConfig: {
+            modifiers: ("Meta" | "Control" | "Shift" | "Alt" | "default")[];
+            hotKeys?: {
+                [x: string]: {
+                    modifiers?: ("Meta" | "Control" | "Shift" | "Alt" | "default")[] | undefined;
+                    event: "closeModal" | "navigateSearchResultsDown" | "selectSearchResult" | "navigateSearchResultsUp" | "openCommandPalette" | "toggleSidebar" | "addTopNav" | "closeTopNav" | "navigateTopNavLeft" | "navigateTopNavRight" | "focusAddressBar" | "jumpToTab" | "jumpToLastTab" | "focusRequestSearch";
+                };
+            } | undefined;
+        } | undefined;
+        activeEnvironmentId: string;
+        cookieUids?: string[];
+        proxyUrl?: string | undefined;
+        themeId: "alternate" | "default" | "moon" | "purple" | "solarized" | "bluePlanet" | "deepSpace" | "saturn" | "kepler" | "mars" | "none";
+    }[];
+};
+//# sourceMappingURL=migration.d.ts.map

package/dist/migrations/v-2.1.0/migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../../../src/migrations/v-2.1.0/migration.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAA;AAInE,mCAAmC;AACnC,eAAO,MAAM,eAAe,SAAU,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC;;;;;;;;;;oBAG/C,CAAC;mBAIjB,CADJ;qBAA4C,CAAC;;;;0BAKlC,CAAC;mBACR,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAiDsD,CAAC;;;;oBASlD,CAAC;;;;;;wBAIF,CAAR;;;;;;sCAM2B,GAAG;oHAMoB,GAAsB;iCAGhE,GAAC;+BACS,GAAG;;+BAKb,CAAC;0BAED,CAAC;4BAIY,CAAA;wBAAoC,CAAC;wBAAqC,CAAC;0BACpF,CAAC;2BAAsC,CAAC;2BAGvC,CAAC;2BAAsC,CAAC;4BACxC,CAAC;;;kBACR,CAAD;;;;;;;;oBAQD,CAAC;2BAAqC,CAAC;sBAElB,CAAC;wBACA,CAAC;oBAAkC,CAAC;oBAG1D,CAAF;sBAAmC,CAAC;uBAE5B,CAAC;uBAAoC,CAAC;uBAChB,CAAC;wBACtB,CAAC;;;;;;oBAOW,CAAC;2BACN,CAAC;sBAAmC,CAAC;wBACpC,CAAC;oBACN,CAAC;oBACP,CAAC;sBAEH,CAAF;uBAAoC,CAAC;uBAAoC,CAAC;uBAC3C,CAAC;wBACP,CAAC;;;;;;oBAOpB,CAAC;2BAEP,CAAD;sBACQ,CAAC;wBAGV,CAAF;oBAAkC,CAAC;oBAC/B,CAAH;sBAGO,CAAL;uBACQ,CAAC;uBAGT,CAAC;uBACsB,CAAC;wBAAkC,CAAC;;;;;;oBAGxB,CAAC;2BACb,CAAC;sBAChB,CAAC;wBAAqC,CAAC;oBACnB,CAAC;oBAClB,CAAC;sBAEY,CAAA;uBAChB,CAAC;uBACL,CAAC;uBACJ,CAAA;wBAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAejC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAkI0oB,CAAC;;6BAA4E,CAAC;;;;;;;;;;CAD9tB,CAAA"}

package/dist/migrations/v-2.1.0/migration.js

@@ -0,0 +1,249 @@
+import { parseLocalStorage } from '../local-storage.js';
+import { camelToTitleWords, capitalize } from '../../helpers/string.js';
+
+/** V-0.0.0 to V-2.1.0 migration */
+const migrate_v_2_1_0 = (data) => {
+    console.info('Performing data migration v-0.0.0 to v-2.1.0');
+    // Augment the previous data
+    const oldData = {
+        ...data,
+        // @ts-expect-error Tags used to be called folders
+        folders: parseLocalStorage('folder'),
+    };
+    /** To grab requests and tags we must traverse children, also for security */
+    const flattenChildren = (childUids) => childUids.reduce((prev, uid) => {
+        const request = oldData.requests[uid];
+        // Request
+        if (request) {
+            prev.requestUids.add(uid);
+            // Security
+            request.securitySchemeUids?.forEach((s) => prev.authUids.add(s));
+        }
+        // Folder -> tag
+        else if (oldData.folders[uid]) {
+            const { requestUids, tagUids, authUids } = flattenChildren(oldData.folders[uid].childUids ?? []);
+            prev.tagUids.add(uid);
+            requestUids.forEach((r) => prev.requestUids.add(r));
+            tagUids.forEach((t) => prev.tagUids.add(t));
+            authUids.forEach((a) => prev.authUids.add(a));
+        }
+        return prev;
+    }, {
+        requestUids: new Set(),
+        tagUids: new Set(),
+        authUids: new Set(),
+    });
+    /** Migrate values from old securitySchemes to the new auth */
+    const migrateAuth = (scheme) => {
+        if (scheme.type === 'apiKey')
+            // ApiKey
+            return { type: 'apiKey', name: scheme.name, value: scheme.value ?? '' };
+        // HTTP
+        if (scheme.type === 'http')
+            return {
+                type: 'http',
+                username: scheme.value ?? '',
+                password: scheme.secondValue ?? '',
+                token: scheme.value ?? '',
+            };
+        // Oauth2 Implicit
+        if (scheme.type === 'oauth2' && scheme.flow.type === 'implicit')
+            return {
+                type: 'oauth-implicit',
+                token: scheme.flow.token ?? '',
+            };
+        // Oauth2 Password
+        if (scheme.type === 'oauth2' && scheme.flow.type === 'password')
+            return {
+                type: 'oauth-password',
+                token: scheme.flow.token ?? '',
+                username: scheme.flow.value ?? '',
+                password: scheme.flow.secondValue ?? '',
+                clientSecret: scheme.flow.clientSecret ?? '',
+            };
+        // Oauth2 clientCredentials
+        if (scheme.type === 'oauth2' && scheme.flow.type === 'clientCredentials')
+            return {
+                type: 'oauth-clientCredentials',
+                token: scheme.flow.token ?? '',
+                clientSecret: scheme.flow.clientSecret ?? '',
+            };
+        // Oauth2 Authorization Code
+        if (scheme.type === 'oauth2' && scheme.flow.type === 'authorizationCode')
+            return {
+                type: 'oauth-authorizationCode',
+                token: scheme.flow.token ?? '',
+                clientSecret: scheme.flow.clientSecret ?? '',
+            };
+        // Default - should not get hit
+        return {
+            type: 'apiKey',
+            name: '',
+            value: '',
+        };
+    };
+    /** This is needed due to our previous data being poluted, we will only allow auth on a requst which is in the spec */
+    const requestSecurityDict = {};
+    // Collections
+    const collections = Object.values(oldData.collections ?? {}).map((c) => {
+        const { requestUids, tagUids, authUids } = flattenChildren(c.childUids ?? []);
+        // Ensure we got unique uids
+        const securitySchemesSet = new Set([
+            ...authUids,
+            ...Object.values(c.securitySchemeDict ?? {}),
+        ]);
+        const securitySchemes = [...securitySchemesSet];
+        // Add this auth to each request
+        requestUids.forEach((r) => (requestSecurityDict[r] = securitySchemes));
+        // Migrate auth
+        const auth = securitySchemes.reduce((prev, uid) => {
+            const scheme = oldData.securitySchemes[uid];
+            if (scheme.uid)
+                prev[uid] = migrateAuth(scheme);
+            return prev;
+        }, {});
+        return {
+            type: 'collection',
+            openapi: c.spec?.openapi || '3.1.0',
+            info: c.spec?.info || { title: 'OpenAPI Spec', version: '0.0.1' },
+            security: c.spec?.security || [],
+            externalDocs: c.spec?.externalDocs,
+            uid: c.uid,
+            securitySchemes,
+            selectedServerUid: c.selectedServerUid || c.spec?.serverUids?.[0] || '',
+            servers: c.spec?.serverUids || [],
+            requests: [...requestUids],
+            tags: [...tagUids],
+            auth,
+            children: c.childUids || [],
+        };
+    });
+    // Cookies
+    const cookies = Object.values(oldData.cookies ?? {});
+    // Environments
+    const environments = Object.values(oldData.environments ?? {}).map((e) => ({
+        ...e,
+        value: e.raw ?? '',
+    }));
+    // Requests
+    const requests = Object.values(oldData.requests ?? {}).map((r) => {
+        // Convert parameters
+        const parameters = [
+            ...Object.values(r.parameters?.path ?? {}),
+            ...Object.values(r.parameters?.query ?? {}),
+            ...Object.values(r.parameters?.headers ?? {}),
+            ...Object.values(r.parameters?.cookies ?? {}),
+        ].filter((p) => p);
+        // Ensure this request can access these schemes
+        const selectedSecuritySchemeUids = (r.selectedSecuritySchemeUids || []).filter((s) => requestSecurityDict[r.uid].includes(s));
+        return {
+            ...r,
+            parameters,
+            type: 'request',
+            method: r.method?.toLowerCase() ?? 'get',
+            examples: r.childUids || [],
+            selectedSecuritySchemeUids,
+            selectedServerUid: '',
+            servers: [],
+        };
+    });
+    // Request Examples
+    const requestExamples = Object.values(oldData.requestExamples ?? {}).map((e) => ({
+        ...e,
+        type: 'requestExample',
+    }));
+    /** Specifically handle each oauth2 flow */
+    const migrateFlow = (flow) => {
+        const base = {
+            refreshUrl: flow.refreshUrl || '',
+            selectedScopes: flow.selectedScopes || [],
+            scopes: flow.scopes || {},
+        };
+        if (flow.type === 'implicit')
+            return {
+                ...flow,
+                ...base,
+                'type': 'implicit',
+                'x-scalar-redirect-uri': ('redirectUri' in flow ? flow.redirectUri : '') || '',
+            };
+        if (flow.type === 'password')
+            return {
+                ...flow,
+                ...base,
+                tokenUrl: flow.tokenUrl || '',
+            };
+        if (flow.type === 'clientCredentials')
+            return {
+                ...flow,
+                ...base,
+                tokenUrl: flow.tokenUrl || '',
+            };
+        return {
+            ...flow,
+            ...base,
+            'x-scalar-redirect-uri': ('redirectUri' in flow ? flow.redirectUri : '') || '',
+            'authorizationUrl': flow.authorizationUrl || '',
+            'tokenUrl': flow.tokenUrl || '',
+        };
+    };
+    /** Generate a nameKey based on the type of oauth */
+    const getNameKey = (scheme) => {
+        switch (scheme?.type) {
+            case 'apiKey':
+                return `${capitalize(scheme.in)}`;
+            case 'http': {
+                return `${capitalize(scheme.scheme)} Authentication`;
+            }
+            case 'oauth2':
+                return camelToTitleWords(scheme.flow.type);
+            case 'openIdConnect':
+                return `Open ID Connect`;
+            default:
+                return 'None';
+        }
+    };
+    // Security Schemes
+    const securitySchemes = Object.values(oldData.securitySchemes ?? {}).map((s) => s.type === 'oauth2'
+        ? {
+            ...s,
+            'nameKey': getNameKey(s),
+            'x-scalar-client-id': s.clientId || '',
+            'flow': migrateFlow(s.flow),
+        }
+        : { ...s, nameKey: getNameKey(s) });
+    // Servers
+    const servers = Object.values(oldData.servers ?? {}).map((s) => ({
+        ...s,
+        variables: s.variables ?? {},
+    }));
+    // Tags
+    const tags = Object.values(oldData.folders ?? {}).map((f) => ({
+        'type': 'tag',
+        'uid': f.uid,
+        'name': f.name || 'unknownTag',
+        'description': f.description,
+        'children': f.childUids || [],
+        'x-scalar-children': [],
+    }));
+    // Workspaces
+    const workspaces = Object.values(oldData.workspaces ?? {}).map((w) => ({
+        ...w,
+        description: w.description ?? 'Basic Scalar Workspace',
+        cookies: w.cookieUids || [],
+        collections: w.collectionUids || [],
+        environments: w.environmentUids || [],
+    }));
+    return {
+        collections,
+        cookies,
+        environments,
+        requestExamples,
+        requests,
+        securitySchemes,
+        servers,
+        tags,
+        workspaces,
+    };
+};
+
+export { migrate_v_2_1_0 };

package/dist/migrations/v-2.1.0/types.generated.d.ts

@@ -0,0 +1,42 @@
+import { Cookie as Ck } from '../../entities/cookie/index.js';
+import { Environment as E } from '../../entities/environment/index.js';
+import { Collection as Co, Request as R, RequestExample as RE, Server as S, SecurityScheme as SS, Tag as T } from '../../entities/spec/index.js';
+import { Workspace as W } from '../../entities/workspace/index.js';
+/**
+ * TODO: These types are no longer generated, this was manually grabbed but we must generate them before the next
+ * migration else we will have issues!
+ */
+export declare namespace v_2_1_0 {
+    type Cookie = Ck;
+    type Environment = E;
+    type Collection = Co;
+    type Request = R;
+    type RequestExample = RE;
+    type SecurityScheme = SS;
+    type Server = S;
+    type Tag = T;
+    type Workspace = W;
+    type DataRecord = {
+        collections: Record<string, Collection>;
+        cookies: Record<string, Cookie>;
+        environments: Record<string, Environment>;
+        requestExamples: Record<string, RequestExample>;
+        requests: Record<string, Request>;
+        securitySchemes: Record<string, SecurityScheme>;
+        servers: Record<string, Server>;
+        tags: Record<string, Tag>;
+        workspaces: Record<string, Workspace>;
+    };
+    type DataArray = {
+        collections: Collection[];
+        cookies: Cookie[];
+        environments: Environment[];
+        requestExamples: RequestExample[];
+        requests: Request[];
+        securitySchemes: SecurityScheme[];
+        servers: Server[];
+        tags: Tag[];
+        workspaces: Workspace[];
+    };
+}
+//# sourceMappingURL=types.generated.d.ts.map

package/dist/migrations/v-2.1.0/types.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.generated.d.ts","sourceRoot":"","sources":["../../../src/migrations/v-2.1.0/types.generated.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,EAAE,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,WAAW,IAAI,CAAC,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EACL,UAAU,IAAI,EAAE,EAChB,OAAO,IAAI,CAAC,EACZ,cAAc,IAAI,EAAE,EACpB,MAAM,IAAI,CAAC,EACX,cAAc,IAAI,EAAE,EACpB,GAAG,IAAI,CAAC,EACT,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,SAAS,IAAI,CAAC,EAAE,MAAM,sBAAsB,CAAA;AAErD;;;GAGG;AACH,yBAAiB,OAAO,CAAC;IACvB,KAAY,MAAM,GAAG,EAAE,CAAA;IACvB,KAAY,WAAW,GAAG,CAAC,CAAA;IAC3B,KAAY,UAAU,GAAG,EAAE,CAAA;IAC3B,KAAY,OAAO,GAAG,CAAC,CAAA;IACvB,KAAY,cAAc,GAAG,EAAE,CAAA;IAC/B,KAAY,cAAc,GAAG,EAAE,CAAA;IAC/B,KAAY,MAAM,GAAG,CAAC,CAAA;IACtB,KAAY,GAAG,GAAG,CAAC,CAAA;IACnB,KAAY,SAAS,GAAG,CAAC,CAAA;IAEzB,KAAY,UAAU,GAAG;QACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;QACvC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC/B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;QACzC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;QAC/C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QACjC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;QAC/C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC/B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;KACtC,CAAA;IAED,KAAY,SAAS,GAAG;QACtB,WAAW,EAAE,UAAU,EAAE,CAAA;QACzB,OAAO,EAAE,MAAM,EAAE,CAAA;QACjB,YAAY,EAAE,WAAW,EAAE,CAAA;QAC3B,eAAe,EAAE,cAAc,EAAE,CAAA;QACjC,QAAQ,EAAE,OAAO,EAAE,CAAA;QACnB,eAAe,EAAE,cAAc,EAAE,CAAA;QACjC,OAAO,EAAE,MAAM,EAAE,CAAA;QACjB,IAAI,EAAE,GAAG,EAAE,CAAA;QACX,UAAU,EAAE,SAAS,EAAE,CAAA;KACxB,CAAA;CACF"}

package/dist/spec-getters/getExampleFromSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getExampleFromSchema.d.ts","sourceRoot":"","sources":["../../src/spec-getters/getExampleFromSchema.ts"],"names":[],"mappings":"AAsCA;;GAEG;AACH,eAAO,MAAM,oBAAoB,WACvB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YACjB;IACR;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,GAAG,CAAC,EAAE,OAAO,CAAA;IACb;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IACvB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC/B;;OAEG;IACH,8BAA8B,CAAC,EAAE,OAAO,CAAA;CACzC,UACM,MAAM,iBACE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,SAC3B,MAAM,KACZ,GAiQF,CAAA"}
+{"version":3,"file":"getExampleFromSchema.d.ts","sourceRoot":"","sources":["../../src/spec-getters/getExampleFromSchema.ts"],"names":[],"mappings":"AAyCA;;GAEG;AACH,eAAO,MAAM,oBAAoB,WACvB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YACjB;IACR;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,GAAG,CAAC,EAAE,OAAO,CAAA;IACb;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IACvB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC/B;;OAEG;IACH,8BAA8B,CAAC,EAAE,OAAO,CAAA;CACzC,UACM,MAAM,iBACE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,SAC3B,MAAM,KACZ,GA4QF,CAAA"}