@stainless-api/docs-ui 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/types/stainless-alias/lib/json-spec-v2/GoAST.d.ts

@@ -0,0 +1,120 @@
+import type * as SDKJSON from './types';
+export type GoDeclaration = GoDeclFunction | GoDeclType | GoDeclProperty | GoDeclTypeAlias | GoDeclConst | GoDeclReference | SDKJSON.ErrorDecl;
+export type GoDeclFunction = SDKJSON.BaseDeclaration & {
+    kind: 'GoDeclFunction';
+    ident: GoIdentifier;
+    qualified?: string;
+    docstring?: string;
+    async?: boolean;
+    generics?: GoGenericParameter[];
+    parameters: GoFunctionParameter[];
+    returnType: GoType[];
+    paramsChildren?: SDKJSON.ID[];
+    responseChildren?: SDKJSON.ID[];
+};
+export type GoFunctionParameter = {
+    kind: 'GoFunctionParameter';
+    optional?: boolean;
+    ident: GoIdentifier;
+    typeAnnotation: GoType;
+};
+export type GoGenericParameter = {
+    kind: 'GoTypeParameter';
+    name: string;
+    constraint?: GoType;
+};
+export type GoDeclType = SDKJSON.BaseDeclaration & {
+    kind: 'GoDeclType';
+    docstring?: string;
+    ident: GoIdentifier;
+    generics?: GoGenericParameter[];
+    type: GoType;
+    children?: SDKJSON.ID[];
+};
+export type GoDeclTypeAlias = SDKJSON.BaseDeclaration & {
+    kind: 'GoDeclTypeAlias';
+    docstring?: string;
+    ident: GoIdentifier;
+    type: GoType;
+    children?: SDKJSON.ID[];
+};
+export type GoDeclConst = SDKJSON.BaseDeclaration & {
+    kind: 'GoDeclConst';
+    docstring?: string;
+    ident: GoIdentifier;
+    type: GoType;
+    value: boolean | string | number;
+    children?: SDKJSON.ID[];
+};
+export type GoIdentifier = string;
+export type GoDeclProperty = SDKJSON.BaseDeclaration & {
+    kind: 'GoDeclProperty';
+    docstring?: string;
+    ident: GoIdentifier;
+    type: GoType;
+    constraints?: SDKJSON.Constraints;
+    optional?: boolean;
+    default?: any;
+    schemaType?: SDKJSON.SchemaType;
+    modelPath?: string;
+    childrenParentSchema?: SDKJSON.SchemaType;
+    children?: SDKJSON.ID[];
+};
+export type GoDeclReference = SDKJSON.BaseDeclaration & {
+    kind: 'GoDeclReference';
+    docstring?: string;
+    type: GoType;
+    children?: SDKJSON.ID[];
+};
+export type GoType = GoTypeReference | GoTypeInterface | GoTypeStruct | GoTypeArray | GoTypeMap | GoTypeString | GoTypeFloat | GoTypeInt | GoTypeBool | GoTypeAny | GoTypeUnknown | GoTypeError | GoTypePointer;
+export type GoTypeReference = SDKJSON.BaseType & {
+    kind: 'GoTypeReference';
+    typeName: GoIdentifier;
+    typeParameters?: GoType[];
+    schemaType?: SDKJSON.SchemaType;
+    $ref?: string;
+};
+export type GoTypeStruct = SDKJSON.BaseType & {
+    kind: 'GoTypeStruct';
+};
+export type GoTypeInterface = SDKJSON.BaseType & {
+    kind: 'GoTypeInterface';
+    docstring?: string;
+    typeName?: GoIdentifier;
+    generics?: GoGenericParameter[];
+    extends?: GoTypeReference[];
+};
+export type GoTypeArray = SDKJSON.BaseType & {
+    kind: 'GoTypeArray';
+    elementType: GoType;
+};
+export type GoTypeMap = SDKJSON.BaseType & {
+    kind: 'GoTypeMap';
+    indexType: GoType;
+    itemType: GoType;
+};
+export type GoTypeString = SDKJSON.BaseType & {
+    kind: 'GoTypeString';
+};
+export type GoTypeFloat = SDKJSON.BaseType & {
+    kind: 'GoTypeFloat';
+};
+export type GoTypeInt = SDKJSON.BaseType & {
+    kind: 'GoTypeInt';
+};
+export type GoTypeBool = SDKJSON.BaseType & {
+    kind: 'GoTypeBool';
+};
+export type GoTypeAny = SDKJSON.BaseType & {
+    kind: 'GoTypeAny';
+};
+export type GoTypeUnknown = SDKJSON.BaseType & {
+    kind: 'GoTypeUnknown';
+};
+export type GoTypeError = SDKJSON.BaseType & {
+    kind: 'GoTypeError';
+};
+export type GoTypePointer = SDKJSON.BaseType & {
+    kind: 'GoTypePointer';
+    inner: GoType;
+};

package/dist/types/stainless-alias/lib/json-spec-v2/GoAST.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=GoAST.js.map

package/dist/types/stainless-alias/lib/json-spec-v2/GoAST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GoAST.js","sourceRoot":"","sources":["../../../../../src/types/stainless-alias/lib/json-spec-v2/GoAST.ts"],"names":[],"mappings":""}

package/dist/types/stainless-alias/lib/json-spec-v2/HttpAST.d.ts

@@ -0,0 +1,100 @@
+import type * as SDKJSON from './types';
+export type HttpDeclaration = HttpDeclFunction | HttpDeclProperty | HttpDeclTypeAlias | HttpDeclReference | SDKJSON.ErrorDecl;
+export type HttpDeclFunction = SDKJSON.BaseDeclaration & {
+    kind: 'HttpDeclFunction';
+    ident: HttpIdentifier;
+    qualified?: string;
+    returns?: HttpType;
+    paramsChildren?: Record<string, SDKJSON.ID[]>;
+    bodyParamsChildren?: Record<string, SDKJSON.ID[]>;
+    responseChildren?: SDKJSON.ID[];
+};
+export type HttpDeclProperty = SDKJSON.BaseDeclaration & {
+    kind: 'HttpDeclProperty';
+    key: string;
+    docstring?: string;
+    location?: string;
+    type: HttpType;
+    constraints?: SDKJSON.Constraints;
+    default?: any;
+    optional?: boolean;
+    nullable?: boolean;
+    declare?: boolean;
+    schemaType?: SDKJSON.SchemaType;
+    modelPath?: string;
+    childrenParentSchema?: SDKJSON.SchemaType;
+    children?: SDKJSON.ID[];
+};
+export type HttpDeclTypeAlias = SDKJSON.BaseDeclaration & {
+    kind: 'HttpDeclTypeAlias';
+    docstring?: string;
+    ident: HttpIdentifier;
+    typeParameters?: HttpTypeParameter[];
+    type: HttpType;
+    children?: SDKJSON.ID[];
+};
+export type HttpTypeParameter = {
+    kind: 'HttpTypeParameter';
+    name: HttpIdentifier;
+    constraint?: HttpType;
+    default?: HttpType;
+};
+export type HttpIdentifier = string;
+export type HttpDeclReference = SDKJSON.BaseDeclaration & {
+    kind: 'HttpDeclReference';
+    docstring?: string;
+    type: HttpType;
+    children?: SDKJSON.ID[];
+};
+export type HttpType = HttpTypeReference | HttpTypeObject | HttpTypeArray | HttpTypeString | HttpTypeNumber | HttpTypeBoolean | HttpTypeNull | HttpTypeUndefined | HttpTypeBinary | HttpTypeUnknown | HttpTypeLiteral | HttpTypeUnion | HttpTypeIntersection;
+export type HttpTypeReference = SDKJSON.BaseType & {
+    kind: 'HttpTypeReference';
+    ident: HttpIdentifier;
+    typeParameters?: HttpType[];
+    $ref?: SDKJSON.ID;
+};
+export type HttpTypeObject = SDKJSON.BaseType & {
+    kind: 'HttpTypeObject';
+    members: {
+        ident: HttpIdentifier;
+        optional?: boolean;
+    }[];
+};
+export type HttpTypeArray = SDKJSON.BaseType & {
+    kind: 'HttpTypeArray';
+    elementType: HttpType;
+};
+export type HttpTypeUnion = SDKJSON.BaseType & {
+    kind: 'HttpTypeUnion';
+    types: HttpType[];
+};
+export type HttpTypeIntersection = SDKJSON.BaseType & {
+    kind: 'HttpTypeIntersection';
+    types: HttpType[];
+};
+export type HttpTypeLiteral = SDKJSON.BaseType & {
+    kind: 'HttpTypeLiteral';
+    literal: string | boolean | number;
+};
+export type HttpTypeString = SDKJSON.BaseType & {
+    kind: 'HttpTypeString';
+};
+export type HttpTypeNumber = SDKJSON.BaseType & {
+    kind: 'HttpTypeNumber';
+};
+export type HttpTypeBoolean = SDKJSON.BaseType & {
+    kind: 'HttpTypeBoolean';
+};
+export type HttpTypeNull = SDKJSON.BaseType & {
+    kind: 'HttpTypeNull';
+};
+export type HttpTypeUndefined = SDKJSON.BaseType & {
+    kind: 'HttpTypeUndefined';
+};
+export type HttpTypeBinary = SDKJSON.BaseType & {
+    kind: 'HttpTypeBinary';
+    contentType: string[];
+};
+export type HttpTypeUnknown = SDKJSON.BaseType & {
+    kind: 'HttpTypeUnknown';
+};

package/dist/types/stainless-alias/lib/json-spec-v2/HttpAST.js

@@ -0,0 +1,3 @@
+// This is loosely based upon the Babel AST for TypeScript.
+export {};
+//# sourceMappingURL=HttpAST.js.map

package/dist/types/stainless-alias/lib/json-spec-v2/HttpAST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpAST.js","sourceRoot":"","sources":["../../../../../src/types/stainless-alias/lib/json-spec-v2/HttpAST.ts"],"names":[],"mappings":"AAAA,2DAA2D"}

package/dist/types/stainless-alias/lib/json-spec-v2/JavaAST.d.ts

@@ -0,0 +1,87 @@
+import type * as SDKJSON from './types';
+export type JavaDeclaration = JavaDeclFunction | JavaDeclType | JavaDeclProperty | JavaDeclConst | JavaDeclReference | SDKJSON.ErrorDecl;
+export type JavaDeclFunction = SDKJSON.BaseDeclaration & {
+    kind: 'JavaDeclFunction';
+    ident: JavaIdentifier;
+    qualified?: string;
+    docstring?: string;
+    async?: boolean;
+    parameters: JavaFunctionParameter[];
+    returnType?: JavaType;
+    paramsChildren?: SDKJSON.ID[];
+    responseChildren?: SDKJSON.ID[];
+};
+export type JavaFunctionParameter = {
+    kind: 'JavaFunctionParameter';
+    ident: JavaIdentifier;
+    typeAnnotation: JavaType;
+    hasDefault: boolean;
+};
+export type JavaDeclType = SDKJSON.BaseDeclaration & {
+    kind: 'JavaDeclType';
+    docstring?: string;
+    ident: JavaIdentifier;
+    type: JavaType;
+    children?: SDKJSON.ID[];
+};
+export type JavaIdentifier = string;
+export type JavaDeclProperty = SDKJSON.BaseDeclaration & {
+    kind: 'JavaDeclProperty';
+    docstring?: string;
+    ident: JavaIdentifier;
+    type: JavaType;
+    optional?: boolean;
+    schemaType?: SDKJSON.SchemaType;
+    modelPath?: string;
+    childrenParentSchema?: SDKJSON.SchemaType;
+    children?: SDKJSON.ID[];
+};
+export type JavaDeclConst = SDKJSON.BaseDeclaration & {
+    kind: 'JavaDeclConst';
+    docstring?: string;
+    ident: JavaIdentifier;
+    type: JavaType;
+    value: boolean | string | number;
+};
+export type JavaDeclReference = SDKJSON.BaseDeclaration & {
+    kind: 'JavaDeclReference';
+    docstring?: string;
+    type: JavaType;
+    schemaType?: SDKJSON.SchemaType;
+    children?: SDKJSON.ID[];
+};
+export type JavaType = JavaTypeReference | JavaTypeClass | JavaTypeUnion | JavaTypeEnum | JavaTypeVoid | JavaTypeBoolean | JavaTypeDouble | JavaTypeLong | JavaTypeString | JavaTypeConstant;
+export type JavaTypeReference = SDKJSON.BaseType & {
+    kind: 'JavaTypeReference';
+    typeName: JavaIdentifier;
+    typeParameters?: JavaType[];
+    $ref?: string;
+};
+export type JavaTypeClass = SDKJSON.BaseType & {
+    kind: 'JavaTypeClass';
+};
+export type JavaTypeUnion = SDKJSON.BaseType & {
+    kind: 'JavaTypeUnion';
+};
+export type JavaTypeEnum = SDKJSON.BaseType & {
+    kind: 'JavaTypeEnum';
+};
+export type JavaTypeVoid = SDKJSON.BaseType & {
+    kind: 'JavaTypeVoid';
+};
+export type JavaTypeBoolean = SDKJSON.BaseType & {
+    kind: 'JavaTypeBoolean';
+};
+export type JavaTypeDouble = SDKJSON.BaseType & {
+    kind: 'JavaTypeDouble';
+};
+export type JavaTypeLong = SDKJSON.BaseType & {
+    kind: 'JavaTypeLong';
+};
+export type JavaTypeString = SDKJSON.BaseType & {
+    kind: 'JavaTypeString';
+};
+export type JavaTypeConstant = SDKJSON.BaseType & {
+    kind: 'JavaTypeConstant';
+    value: string;
+};

package/dist/types/stainless-alias/lib/json-spec-v2/JavaAST.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=JavaAST.js.map

package/dist/types/stainless-alias/lib/json-spec-v2/JavaAST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JavaAST.js","sourceRoot":"","sources":["../../../../../src/types/stainless-alias/lib/json-spec-v2/JavaAST.ts"],"names":[],"mappings":""}

package/dist/types/stainless-alias/lib/json-spec-v2/PythonAST.d.ts

@@ -0,0 +1,110 @@
+import type * as SDKJSON from './types';
+export type PythonDeclaration = PythonDeclFunction | PythonDeclClass | PythonDeclType | PythonDeclProperty | PythonDeclReference | SDKJSON.ErrorDecl;
+export type PythonDeclFunction = SDKJSON.BaseDeclaration & {
+    kind: 'PythonDeclFunction';
+    ident: PythonIdentifier;
+    qualified?: string;
+    docstring?: string;
+    async?: boolean;
+    generics?: PythonGenericParameter[];
+    parameters: PythonFunctionParameter[];
+    returns?: PythonType;
+    paramsChildren?: SDKJSON.ID[];
+    responseChildren?: SDKJSON.ID[];
+};
+export type PythonFunctionParameter = {
+    kind: 'PythonFunctionParameter';
+    ident: PythonIdentifier;
+    type: PythonType;
+    optional?: boolean;
+};
+export type PythonGenericParameter = {
+    kind: 'PythonTypeParameter';
+    name: string;
+    constraint?: PythonType;
+};
+export type PythonDeclClass = SDKJSON.BaseDeclaration & {
+    kind: 'PythonDeclClass';
+    docstring?: string;
+    ident: PythonIdentifier;
+    generics?: PythonGenericParameter[];
+    children?: SDKJSON.ID[];
+};
+export type PythonDeclType = SDKJSON.BaseDeclaration & {
+    kind: 'PythonDeclType';
+    docstring?: string;
+    ident: PythonIdentifier;
+    generics?: PythonGenericParameter[];
+    type: PythonType;
+    children?: SDKJSON.ID[];
+};
+export type PythonIdentifier = string;
+export type PythonLiteral = {
+    kind: 'PythonLiteral';
+    value: string | number | boolean;
+};
+export type PythonDeclProperty = SDKJSON.BaseDeclaration & {
+    kind: 'PythonDeclProperty';
+    docstring?: string;
+    ident: PythonIdentifier;
+    type: PythonType;
+    constraints?: SDKJSON.Constraints;
+    optional?: boolean;
+    default?: any;
+    schemaType?: SDKJSON.SchemaType;
+    modelPath?: string;
+    childrenParentSchema?: SDKJSON.SchemaType;
+    children?: SDKJSON.ID[];
+};
+export type PythonDeclReference = SDKJSON.BaseDeclaration & {
+    kind: 'PythonDeclReference';
+    docstring?: string;
+    type: PythonType;
+    children?: SDKJSON.ID[];
+};
+export type PythonType = PythonTypeReference | PythonTypeClass | PythonTypeArray | PythonTypeMap | PythonTypeString | PythonTypeFloat | PythonTypeInt | PythonTypeBool | PythonTypeAny | PythonTypeUnknown | PythonTypeLiteral;
+export type PythonTypeReference = SDKJSON.BaseType & {
+    kind: 'PythonTypeReference';
+    typeName: PythonIdentifier;
+    typeParameters?: PythonType[];
+    schemaType?: SDKJSON.SchemaType;
+    $ref?: string;
+};
+export type PythonTypeClass = SDKJSON.BaseType & {
+    kind: 'PythonTypeClass';
+    body: {
+        ident: PythonIdentifier;
+        type: PythonType;
+    }[];
+};
+export type PythonTypeArray = SDKJSON.BaseType & {
+    kind: 'PythonTypeArray';
+    elementType: PythonType;
+};
+export type PythonTypeMap = SDKJSON.BaseType & {
+    kind: 'PythonTypeMap';
+    indexType: PythonType;
+    itemType: PythonType;
+};
+export type PythonTypeString = SDKJSON.BaseType & {
+    kind: 'PythonTypeString';
+};
+export type PythonTypeFloat = SDKJSON.BaseType & {
+    kind: 'PythonTypeFloat';
+};
+export type PythonTypeInt = SDKJSON.BaseType & {
+    kind: 'PythonTypeInt';
+};
+export type PythonTypeBool = SDKJSON.BaseType & {
+    kind: 'PythonTypeBool';
+};
+export type PythonTypeAny = SDKJSON.BaseType & {
+    kind: 'PythonTypeAny';
+};
+export type PythonTypeUnknown = SDKJSON.BaseType & {
+    kind: 'PythonTypeUnknown';
+};
+export type PythonTypeLiteral = SDKJSON.BaseType & {
+    kind: 'PythonTypeLiteral';
+    literal: PythonLiteral;
+};

package/dist/types/stainless-alias/lib/json-spec-v2/PythonAST.js

@@ -0,0 +1,3 @@
+// This is loosely based upon the Babel AST for TypeScript.
+export {};
+//# sourceMappingURL=PythonAST.js.map

package/dist/types/stainless-alias/lib/json-spec-v2/PythonAST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PythonAST.js","sourceRoot":"","sources":["../../../../../src/types/stainless-alias/lib/json-spec-v2/PythonAST.ts"],"names":[],"mappings":"AAAA,2DAA2D"}

package/dist/types/stainless-alias/lib/json-spec-v2/RubyAST.d.ts

@@ -0,0 +1,122 @@
+import type * as SDKJSON from './types';
+export type RubyDeclaration = RubyDeclFunction | RubyDeclClass | RubyDeclProperty | RubyDeclTypeAlias | RubyDeclReference | SDKJSON.ErrorDecl;
+export type RubyDeclFunction = SDKJSON.BaseDeclaration & {
+    kind: 'RubyDeclFunction';
+    ident: RubyIdentifier;
+    args: RubyFunctionArgument[];
+    qualified?: string;
+    returns?: RubyType;
+    paramsChildren?: SDKJSON.ID[];
+    bodyParamsChildren?: Record<string, SDKJSON.ID[]>;
+    responseChildren?: SDKJSON.ID[];
+};
+export type RubyFunctionArgument = {
+    kind: 'RubyFunctionArgument';
+    ident: RubyIdentifier;
+    optional: boolean;
+    type: RubyType;
+};
+export type RubyDeclProperty = SDKJSON.BaseDeclaration & {
+    kind: 'RubyDeclProperty';
+    ident: string;
+    docstring?: string;
+    location?: string;
+    type: RubyType;
+    constraints?: SDKJSON.Constraints;
+    optional?: boolean;
+    schemaType?: SDKJSON.SchemaType;
+    modelPath?: string;
+    childrenParentSchema?: SDKJSON.SchemaType;
+    children?: SDKJSON.ID[];
+};
+export type RubyDeclClass = SDKJSON.BaseDeclaration & {
+    kind: 'RubyDeclClass';
+    ident: string;
+    docstring?: string;
+    type: RubyType;
+    optional?: boolean;
+    children?: SDKJSON.ID[];
+};
+export type RubyDeclTypeAlias = SDKJSON.BaseDeclaration & {
+    kind: 'RubyDeclTypeAlias';
+    docstring?: string;
+    ident: RubyIdentifier;
+    typeParameters?: RubyTypeParameter[];
+    type: RubyType;
+    children?: SDKJSON.ID[];
+};
+export type RubyTypeParameter = {
+    kind: 'RubyTypeParameter';
+    name: RubyIdentifier;
+    constraint?: RubyType;
+    default?: RubyType;
+};
+export type RubyIdentifier = string;
+export type RubyDeclReference = SDKJSON.BaseDeclaration & {
+    kind: 'RubyDeclReference';
+    docstring?: string;
+    type: RubyType;
+    children?: SDKJSON.ID[];
+};
+export type RubyType = RubyTypeReference | RubyTypeObject | RubyTypeArray | RubyTypeMap | RubyTypeString | RubyTypeInteger | RubyTypeFloat | RubyTypeBoolean | RubyTypeNull | RubyTypeBinary | RubyTypeUnknown | RubyTypeLiteral | RubyTypeUnion | RubyTypeIntersection | RubyTypeBuiltinClass;
+export type RubyTypeReference = SDKJSON.BaseType & {
+    kind: 'RubyTypeReference';
+    ident: RubyIdentifier;
+    typeParameters?: RubyType[];
+    schemaType?: SDKJSON.SchemaType;
+    $ref?: SDKJSON.ID;
+};
+export type RubyTypeObject = SDKJSON.BaseType & {
+    kind: 'RubyTypeObject';
+    members: {
+        ident: RubyIdentifier;
+        optional?: boolean;
+    }[];
+};
+export type RubyTypeMap = SDKJSON.BaseType & {
+    kind: 'RubyTypeMap';
+    indexType: RubyType;
+    itemType: RubyType;
+};
+export type RubyTypeArray = SDKJSON.BaseType & {
+    kind: 'RubyTypeArray';
+    elementType: RubyType;
+};
+export type RubyTypeUnion = SDKJSON.BaseType & {
+    kind: 'RubyTypeUnion';
+    types: RubyType[];
+};
+export type RubyTypeIntersection = SDKJSON.BaseType & {
+    kind: 'RubyTypeIntersection';
+    types: RubyType[];
+};
+export type RubyTypeLiteral = SDKJSON.BaseType & {
+    kind: 'RubyTypeLiteral';
+    literal: string | boolean | number;
+};
+export type RubyTypeBuiltinClass = SDKJSON.BaseType & {
+    kind: 'RubyTypeBuiltinClass';
+    className: string;
+};
+export type RubyTypeString = SDKJSON.BaseType & {
+    kind: 'RubyTypeString';
+};
+export type RubyTypeInteger = SDKJSON.BaseType & {
+    kind: 'RubyTypeInteger';
+};
+export type RubyTypeFloat = SDKJSON.BaseType & {
+    kind: 'RubyTypeFloat';
+};
+export type RubyTypeBoolean = SDKJSON.BaseType & {
+    kind: 'RubyTypeBoolean';
+};
+export type RubyTypeNull = SDKJSON.BaseType & {
+    kind: 'RubyTypeNull';
+};
+export type RubyTypeBinary = SDKJSON.BaseType & {
+    kind: 'RubyTypeBinary';
+    contentType: string[];
+};
+export type RubyTypeUnknown = SDKJSON.BaseType & {
+    kind: 'RubyTypeUnknown';
+};

package/dist/types/stainless-alias/lib/json-spec-v2/RubyAST.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RubyAST.js.map

package/dist/types/stainless-alias/lib/json-spec-v2/RubyAST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RubyAST.js","sourceRoot":"","sources":["../../../../../src/types/stainless-alias/lib/json-spec-v2/RubyAST.ts"],"names":[],"mappings":""}