diff --git a/.prettierignore b/.prettierignore new file mode 100644 index 000000000..89ac44719 --- /dev/null +++ b/.prettierignore @@ -0,0 +1,7 @@ +**/.circleci +**/.github +**/bin +**/dist +**/docs +**/node_modules +**/samples diff --git a/.prettierrc.json b/.prettierrc.json index d7d68f56b..995a3cf65 100644 --- a/.prettierrc.json +++ b/.prettierrc.json @@ -1,8 +1,16 @@ { - "semi": true, - "singleQuote": true, - "trailingComma": "es5", "arrowParens": "avoid", + "bracketSpacing": true, + "endOfLine": "lf", + "htmlWhitespaceSensitivity": "css", + "insertPragma": false, "printWidth": 120, - "tabWidth": 4 + "proseWrap": "always", + "quoteProps": "as-needed", + "requirePragma": false, + "semi": true, + "singleQuote": true, + "tabWidth": 4, + "trailingComma": "all", + "useTabs": false } diff --git a/CHANGELOG.md b/CHANGELOG.md index a7859f80e..a9d9029be 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,94 +1,133 @@ # Changelog + All notable changes to this project will be documented in this file. ## [0.23.0] - 2022-06-02 + ### Fixed -- Upgraded dependencies -- Added blank line at the end of generated files -- Added support for Node.js v12 + +- Upgraded dependencies +- Added blank line at the end of generated files +- Added support for Node.js v12 + ### Added -- Added `request` property inside `ApiError` -- Added support for `@depricated` inside models and operations + +- Added `request` property inside `ApiError` +- Added support for `@depricated` inside models and operations ## [0.22.0] - 2022-04-26 + ### Fixed -- Upgraded dependencies -- Fixed issue with `null` value inside comments for OpenAPI v2 enums -- Fixed issue with compatibility for latest version of Axios (0.27.x) + +- Upgraded dependencies +- Fixed issue with `null` value inside comments for OpenAPI v2 enums +- Fixed issue with compatibility for latest version of Axios (0.27.x) + ### Removed -- Removed deprecated enum model generation + +- Removed deprecated enum model generation ## [0.21.0] - 2022-04-06 + ### Fixed -- Return `undefined` to match `noImplicitReturns` rule -- Made `BaseHttpRequest` class abstract -- Removed private fields using `#` inside `CancelablePromise` -- Removed unneeded import `AbortController` from `node-fetch` client -- Filter out wrong enum values + +- Return `undefined` to match `noImplicitReturns` rule +- Made `BaseHttpRequest` class abstract +- Removed private fields using `#` inside `CancelablePromise` +- Removed unneeded import `AbortController` from `node-fetch` client +- Filter out wrong enum values ## [0.20.1] - 2022-02-25 + ### Fixed -- Support enums with single quotes in names for V2 + +- Support enums with single quotes in names for V2 ## [0.20.0] - 2022-02-25 + ### Fixed -- Updated dependencies -- Support enums with single quotes in names for V3 -- Generating better names when `operationId` is not given (breaking change) -- Fixed issue where `x-enum` flags where breaking due to non-string values + +- Updated dependencies +- Support enums with single quotes in names for V3 +- Generating better names when `operationId` is not given (breaking change) +- Fixed issue where `x-enum` flags where breaking due to non-string values ## [0.19.0] - 2022-02-02 + ### Added -- Support for Angular client with `--name` option -- Added test cases for Angular client + +- Support for Angular client with `--name` option +- Added test cases for Angular client ## [0.18.2] - 2022-02-02 + ### Fixed -- Updated dependencies -- Fixed type definition + +- Updated dependencies +- Fixed type definition + ### Added -- Added test cases for CLI commands -- Added test cases for query parsing + +- Added test cases for CLI commands +- Added test cases for query parsing ## [0.18.1] - 2022-01-31 + ### Fixed -- Escaping error description -- Made `Client.request` and `BaseHttpRequest.config` props public -_## [0.18.0] - 2022-01-28 +- Escaping error description +- Made `Client.request` and `BaseHttpRequest.config` props public + +\_## [0.18.0] - 2022-01-28 + ### Added -- Angular client generation! -- Updated documentation with more examples and better descriptions + +- Angular client generation! +- Updated documentation with more examples and better descriptions ## [0.17.0] - 2022-01-26 + ### Fixed -- Shorthand notation for properties passed through constructor -- Simplified creation of headers -- Prepare codebase for Angular client + +- Shorthand notation for properties passed through constructor +- Simplified creation of headers +- Prepare codebase for Angular client ## [0.16.2] - 2022-01-26 + ### Fixed -- Removed dependency on `URLSearchParams` to support browser and node without any additional imports + +- Removed dependency on `URLSearchParams` to support browser and node without any additional imports ## [0.16.1] - 2022-01-26 + ### Fixed -- Correct export inside `index.ts` when giving a custom name + +- Correct export inside `index.ts` when giving a custom name ## [0.16.0] - 2022-01-25 + ### Added -- Added option to set the indentation (spaces and tabs) -- Added option to export separate client file that allows usage for multiple backends + +- Added option to set the indentation (spaces and tabs) +- Added option to export separate client file that allows usage for multiple backends + ### Fixed -- Decoupled OpenAPI object from requests -- Updated dependencies + +- Decoupled OpenAPI object from requests +- Updated dependencies ## [0.15.0] - 2022-01-24 + ### Added -- Added change log and releases on GitHub + +- Added change log and releases on GitHub ## [0.14.0] - 2022-01-24 + ### Fixed -- Added missing `postfix` options to typedef -- Updated escaping of comments and descriptions -- Better handling of services without tags -- Updated dependencies + +- Added missing `postfix` options to typedef +- Updated escaping of comments and descriptions +- Better handling of services without tags +- Updated dependencies diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md index 1fb77fa97..5971d2a36 100644 --- a/CODE_OF_CONDUCT.md +++ b/CODE_OF_CONDUCT.md @@ -2,75 +2,60 @@ ## Our Pledge -In the interest of fostering an open and welcoming environment, we as -contributors and maintainers pledge to making participation in our project and -our community a harassment-free experience for everyone, regardless of age, body -size, disability, ethnicity, sex characteristics, gender identity and expression, -level of experience, education, socio-economic status, nationality, personal -appearance, race, religion, or sexual identity and orientation. +In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making +participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, +disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, +socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation. ## Our Standards -Examples of behavior that contributes to creating a positive environment -include: +Examples of behavior that contributes to creating a positive environment include: -* Using welcoming and inclusive language -* Being respectful of differing viewpoints and experiences -* Gracefully accepting constructive criticism -* Focusing on what is best for the community -* Showing empathy towards other community members +- Using welcoming and inclusive language +- Being respectful of differing viewpoints and experiences +- Gracefully accepting constructive criticism +- Focusing on what is best for the community +- Showing empathy towards other community members Examples of unacceptable behavior by participants include: -* The use of sexualized language or imagery and unwelcome sexual attention or - advances -* Trolling, insulting/derogatory comments, and personal or political attacks -* Public or private harassment -* Publishing others' private information, such as a physical or electronic - address, without explicit permission -* Other conduct which could reasonably be considered inappropriate in a - professional setting +- The use of sexualized language or imagery and unwelcome sexual attention or advances +- Trolling, insulting/derogatory comments, and personal or political attacks +- Public or private harassment +- Publishing others' private information, such as a physical or electronic address, without explicit permission +- Other conduct which could reasonably be considered inappropriate in a professional setting ## Our Responsibilities -Project maintainers are responsible for clarifying the standards of acceptable -behavior and are expected to take appropriate and fair corrective action in -response to any instances of unacceptable behavior. +Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take +appropriate and fair corrective action in response to any instances of unacceptable behavior. -Project maintainers have the right and responsibility to remove, edit, or -reject comments, commits, code, wiki edits, issues, and other contributions -that are not aligned to this Code of Conduct, or to ban temporarily or -permanently any contributor for other behaviors that they deem inappropriate, -threatening, offensive, or harmful. +Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, +issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any +contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. ## Scope -This Code of Conduct applies both within project spaces and in public spaces -when an individual is representing the project or its community. Examples of -representing a project or community include using an official project e-mail -address, posting via an official social media account, or acting as an appointed -representative at an online or offline event. Representation of a project may be -further defined and clarified by project maintainers. +This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the +project or its community. Examples of representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed representative at an online or offline +event. Representation of a project may be further defined and clarified by project maintainers. ## Enforcement -Instances of abusive, harassing, or otherwise unacceptable behavior may be -reported by contacting the project team at info@madebyferdi.com. All -complaints will be reviewed and investigated and will result in a response that -is deemed necessary and appropriate to the circumstances. The project team is -obligated to maintain confidentiality with regard to the reporter of an incident. -Further details of specific enforcement policies may be posted separately. +Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at +info@madebyferdi.com. All complaints will be reviewed and investigated and will result in a response that is deemed +necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to +the reporter of an incident. Further details of specific enforcement policies may be posted separately. -Project maintainers who do not follow or enforce the Code of Conduct in good -faith may face temporary or permanent repercussions as determined by other -members of the project's leadership. +Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent +repercussions as determined by other members of the project's leadership. ## Attribution -This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, -available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at +https://www.contributor-covenant.org/version/1/4/code-of-conduct.html [homepage]: https://www.contributor-covenant.org -For answers to common questions about this code of conduct, see -https://www.contributor-covenant.org/faq +For answers to common questions about this code of conduct, see https://www.contributor-covenant.org/faq diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index dbc874d72..7bf84763b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -4,19 +4,18 @@ Thanks for your interest in contributing to this project. ## Pull Request guidelines -Before working on a Pull Request, create an issue explaining what you want to contribute. -This ensures that your pull request won't go unnoticed, and that you are not contributing -something that is not suitable for the project. +Before working on a Pull Request, create an issue explaining what you want to contribute. This ensures that your pull +request won't go unnoticed, and that you are not contributing something that is not suitable for the project. If you are unfamiliar with GitHub Pull Requests, please read the following documentation: https://help.github.com/articles/using-pull-requests **Your Pull Request must:** -* Address a single issue or add a single item of functionality. -* Contain a clean history of small, incremental, logically separate commits, with no merge commits. -* Use clear commit messages. -* Be possible to merge automatically. +- Address a single issue or add a single item of functionality. +- Contain a clean history of small, incremental, logically separate commits, with no merge commits. +- Use clear commit messages. +- Be possible to merge automatically. ## Submitting a Pull Request @@ -27,5 +26,5 @@ https://help.github.com/articles/using-pull-requests 5. Ensure the code is formatted by running: `npm run eslint:fix` 6. Commit your changes using a descriptive commit message -After your Pull Request is created, it will automatically be build using Circle CI. -When the build is successful then the Pull Request is ready for review. +After your Pull Request is created, it will automatically be build using Circle CI. When the build is successful then +the Pull Request is ready for review. diff --git a/README.md b/README.md index 429f905ee..052495143 100644 --- a/README.md +++ b/README.md @@ -1,26 +1,24 @@ # OpenAPI Typescript Codegen -[![NPM][npm-image]][npm-url] -[![License][license-image]][license-url] -[![Coverage][coverage-image]][coverage-url] -[![Quality][quality-image]][quality-url] -[![Code Climate][climate-image]][climate-url] -[![Downloads][downloads-image]][downloads-url] -[![Build][build-image]][build-url] +[![NPM][npm-image]][npm-url] [![License][license-image]][license-url] [![Coverage][coverage-image]][coverage-url] +[![Quality][quality-image]][quality-url] [![Code Climate][climate-image]][climate-url] +[![Downloads][downloads-image]][downloads-url] [![Build][build-image]][build-url] > Node.js library that generates Typescript clients based on the OpenAPI specification. ## Why? -- Frontend ❤️ OpenAPI, but we do not want to use JAVA codegen in our builds -- Quick, lightweight, robust and framework-agnostic 🚀 -- Supports generation of TypeScript clients -- Supports generations of Fetch, [Node-Fetch](#node-fetch-support), [Axios](#axios-support), [Angular](#angular-support) and XHR http clients -- Supports OpenAPI specification v2.0 and v3.0 -- Supports JSON and YAML files for input -- Supports generation through CLI, Node.js and NPX -- Supports tsc and @babel/plugin-transform-typescript -- Supports aborting of requests (cancelable promise pattern) -- Supports external references using [json-schema-ref-parser](https://github.com/APIDevTools/json-schema-ref-parser/) + +- Frontend ❤️ OpenAPI, but we do not want to use JAVA codegen in our builds +- Quick, lightweight, robust and framework-agnostic 🚀 +- Supports generation of TypeScript clients +- Supports generations of Fetch, [Node-Fetch](#node-fetch-support), [Axios](#axios-support), + [Angular](#angular-support) and XHR http clients +- Supports OpenAPI specification v2.0 and v3.0 +- Supports JSON and YAML files for input +- Supports generation through CLI, Node.js and NPX +- Supports tsc and @babel/plugin-transform-typescript +- Supports aborting of requests (cancelable promise pattern) +- Supports external references using [json-schema-ref-parser](https://github.com/APIDevTools/json-schema-ref-parser/) ## Install @@ -58,27 +56,27 @@ $ openapi --help $ openapi --input ./spec.json --output ./generated --client xhr ``` -Documentation -=== -- [Basic usage](docs/basic-usage.md) -- [OpenAPI object](docs/openapi-object.md) -- [Client instances](docs/client-instances.md) `--name` -- [Argument vs. Object style](docs/arguments-vs-object-style.md) `--useOptions` -- [Enums vs. Union types](docs/enum-vs-union-types.md) `--useUnionTypes` -- [Runtime schemas](docs/runtime-schemas.md) `--exportSchemas` -- [Enum with custom names and descriptions](docs/custom-enums.md) -- [Nullable props (OpenAPI v2)](docs/nullable-props.md) -- [Authorization](docs/authorization.md) -- [External references](docs/external-references.md) -- [Canceling requests](docs/canceling-requests.md) -- [Custom request file](docs/custom-request-file.md) - -Support -=== -- [Babel support](docs/babel-support.md) -- [Axios support](docs/axios-support.md) -- [Angular support](docs/angular-support.md) -- [Node-Fetch support](docs/node-fetch-support.md) +# Documentation + +- [Basic usage](docs/basic-usage.md) +- [OpenAPI object](docs/openapi-object.md) +- [Client instances](docs/client-instances.md) `--name` +- [Argument vs. Object style](docs/arguments-vs-object-style.md) `--useOptions` +- [Enums vs. Union types](docs/enum-vs-union-types.md) `--useUnionTypes` +- [Runtime schemas](docs/runtime-schemas.md) `--exportSchemas` +- [Enum with custom names and descriptions](docs/custom-enums.md) +- [Nullable props (OpenAPI v2)](docs/nullable-props.md) +- [Authorization](docs/authorization.md) +- [External references](docs/external-references.md) +- [Canceling requests](docs/canceling-requests.md) +- [Custom request file](docs/custom-request-file.md) + +# Support + +- [Babel support](docs/babel-support.md) +- [Axios support](docs/axios-support.md) +- [Angular support](docs/angular-support.md) +- [Node-Fetch support](docs/node-fetch-support.md) [npm-url]: https://npmjs.org/package/openapi-typescript-codegen [npm-image]: https://img.shields.io/npm/v/openapi-typescript-codegen.svg diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 000000000..6f2825319 --- /dev/null +++ b/dist/index.js @@ -0,0 +1,7601 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { value: true }); + +var camelCase = require('camelcase'); +var RefParser = require('json-schema-ref-parser'); +var os = require('os'); +var path = require('path'); +var fsExtra = require('fs-extra'); + +exports.HttpClient = void 0; +(function (HttpClient) { + HttpClient["FETCH"] = "fetch"; + HttpClient["XHR"] = "xhr"; + HttpClient["NODE"] = "node"; + HttpClient["AXIOS"] = "axios"; + HttpClient["ANGULAR"] = "angular"; +})(exports.HttpClient || (exports.HttpClient = {})); + +exports.Indent = void 0; +(function (Indent) { + Indent["SPACE_4"] = "4"; + Indent["SPACE_2"] = "2"; + Indent["TAB"] = "tab"; +})(exports.Indent || (exports.Indent = {})); + +const reservedWords$1 = /^(arguments|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|eval|export|extends|false|finally|for|function|if|implements|import|in|instanceof|interface|let|new|null|package|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)$/g; +/** + * Replaces any invalid characters from a parameter name. + * For example: 'filter.someProperty' becomes 'filterSomeProperty'. + */ +const getOperationParameterName$1 = (value) => { + const clean = value + .replace(/^[^a-zA-Z]+/g, '') + .replace(/[^\w\-]+/g, '-') + .trim(); + return camelCase(clean).replace(reservedWords$1, '_$1'); +}; + +/** + * The spec generates a pattern like this '^\d{3}-\d{2}-\d{4}$' + * However, to use it in HTML or inside new RegExp() we need to + * escape the pattern to become: '^\\d{3}-\\d{2}-\\d{4}$' in order + * to make it a valid regexp string. + * + * Also, escape single quote characters, because the output uses single quotes for strings + * + * @param pattern + */ +const getPattern = (pattern) => { + // eslint-disable-next-line prettier/prettier + return pattern === null || pattern === void 0 ? void 0 : pattern.replace(/\\/g, '\\\\').replace(/'/g, "\\'"); +}; + +const isString = (val) => { + return typeof val === 'string'; +}; + +/** + * Extend the enum with the x-enum properties. This adds the capability + * to use names and descriptions inside the generated enums. + * @param enumerators + * @param definition + */ +const extendEnum$1 = (enumerators, definition) => { + var _a, _b; + const names = (_a = definition['x-enum-varnames']) === null || _a === void 0 ? void 0 : _a.filter(isString); + const descriptions = (_b = definition['x-enum-descriptions']) === null || _b === void 0 ? void 0 : _b.filter(isString); + return enumerators.map((enumerator, index) => ({ + name: (names === null || names === void 0 ? void 0 : names[index]) || enumerator.name, + description: (descriptions === null || descriptions === void 0 ? void 0 : descriptions[index]) || enumerator.description, + value: enumerator.value, + type: enumerator.type, + })); +}; + +const getEnum$1 = (values) => { + if (Array.isArray(values)) { + return values + .filter((value, index, arr) => { + return arr.indexOf(value) === index; + }) + .filter((value) => { + return typeof value === 'number' || typeof value === 'string'; + }) + .map(value => { + if (typeof value === 'number') { + return { + name: `'_${value}'`, + value: String(value), + type: 'number', + description: null, + }; + } + return { + name: String(value) + .replace(/\W+/g, '_') + .replace(/^(\d+)/g, '_$1') + .replace(/([a-z])([A-Z]+)/g, '$1_$2') + .toUpperCase(), + value: `'${value.replace(/'/g, "\\'")}'`, + type: 'string', + description: null, + }; + }); + } + return []; +}; + +const escapeName$1 = (value) => { + if (value || value === '') { + const validName = /^[a-zA-Z_$][\w$]+$/g.test(value); + if (!validName) { + return `'${value}'`; + } + } + return value; +}; + +const TYPE_MAPPINGS$1 = new Map([ + ['file', 'binary'], + ['any', 'any'], + ['object', 'any'], + ['array', 'any[]'], + ['boolean', 'boolean'], + ['byte', 'number'], + ['int', 'number'], + ['integer', 'number'], + ['float', 'number'], + ['double', 'number'], + ['short', 'number'], + ['long', 'number'], + ['number', 'number'], + ['char', 'string'], + ['date', 'string'], + ['date-time', 'string'], + ['password', 'string'], + ['string', 'string'], + ['void', 'void'], + ['null', 'null'], +]); +/** + * Get mapped type for given type to any basic Typescript/Javascript type. + */ +const getMappedType$1 = (type, format) => { + if (format === 'binary') { + return 'binary'; + } + return TYPE_MAPPINGS$1.get(type); +}; + +/** + * Strip (OpenAPI) namespaces fom values. + * @param value + */ +const stripNamespace$1 = (value) => { + return value + .trim() + .replace(/^#\/definitions\//, '') + .replace(/^#\/parameters\//, '') + .replace(/^#\/responses\//, '') + .replace(/^#\/securityDefinitions\//, ''); +}; + +const encode$1 = (value) => { + return value.replace(/^[^a-zA-Z_$]+/g, '').replace(/[^\w$]+/g, '_'); +}; +/** + * Parse any string value into a type object. + * @param type String value like "integer" or "Link[Model]". + * @param format String value like "binary" or "date". + */ +const getType$1 = (type = 'any', format) => { + const result = { + type: 'any', + base: 'any', + template: null, + imports: [], + isNullable: false, + }; + const mapped = getMappedType$1(type, format); + if (mapped) { + result.type = mapped; + result.base = mapped; + return result; + } + const typeWithoutNamespace = decodeURIComponent(stripNamespace$1(type)); + if (/\[.*\]$/g.test(typeWithoutNamespace)) { + const matches = typeWithoutNamespace.match(/(.*?)\[(.*)\]$/); + if (matches === null || matches === void 0 ? void 0 : matches.length) { + const match1 = getType$1(encode$1(matches[1])); + const match2 = getType$1(encode$1(matches[2])); + if (match1.type === 'any[]') { + result.type = `${match2.type}[]`; + result.base = match2.type; + match1.imports = []; + } + else if (match2.type) { + result.type = `${match1.type}<${match2.type}>`; + result.base = match1.type; + result.template = match2.type; + } + else { + result.type = match1.type; + result.base = match1.type; + result.template = match1.type; + } + result.imports.push(...match1.imports); + result.imports.push(...match2.imports); + return result; + } + } + if (typeWithoutNamespace) { + const type = encode$1(typeWithoutNamespace); + result.type = type; + result.base = type; + result.imports.push(type); + return result; + } + return result; +}; + +const getModelProperties$1 = (openApi, definition, getModel) => { + var _a; + const models = []; + for (const propertyName in definition.properties) { + if (definition.properties.hasOwnProperty(propertyName)) { + const property = definition.properties[propertyName]; + const propertyRequired = !!((_a = definition.required) === null || _a === void 0 ? void 0 : _a.includes(propertyName)); + if (property.$ref) { + const model = getType$1(property.$ref); + models.push({ + name: escapeName$1(propertyName), + export: 'reference', + type: model.type, + base: model.base, + template: model.template, + link: null, + description: property.description || null, + isDefinition: false, + isReadOnly: property.readOnly === true, + isRequired: propertyRequired, + isNullable: property['x-nullable'] === true, + format: property.format, + maximum: property.maximum, + exclusiveMaximum: property.exclusiveMaximum, + minimum: property.minimum, + exclusiveMinimum: property.exclusiveMinimum, + multipleOf: property.multipleOf, + maxLength: property.maxLength, + minLength: property.minLength, + maxItems: property.maxItems, + minItems: property.minItems, + uniqueItems: property.uniqueItems, + maxProperties: property.maxProperties, + minProperties: property.minProperties, + pattern: getPattern(property.pattern), + imports: model.imports, + enum: [], + enums: [], + properties: [], + }); + } + else { + const model = getModel(openApi, property); + models.push({ + name: escapeName$1(propertyName), + export: model.export, + type: model.type, + base: model.base, + template: model.template, + link: model.link, + description: property.description || null, + isDefinition: false, + isReadOnly: property.readOnly === true, + isRequired: propertyRequired, + isNullable: property['x-nullable'] === true, + format: property.format, + maximum: property.maximum, + exclusiveMaximum: property.exclusiveMaximum, + minimum: property.minimum, + exclusiveMinimum: property.exclusiveMinimum, + multipleOf: property.multipleOf, + maxLength: property.maxLength, + minLength: property.minLength, + maxItems: property.maxItems, + minItems: property.minItems, + uniqueItems: property.uniqueItems, + maxProperties: property.maxProperties, + minProperties: property.minProperties, + pattern: getPattern(property.pattern), + imports: model.imports, + enum: model.enum, + enums: model.enums, + properties: model.properties, + }); + } + } + } + return models; +}; + +const ESCAPED_REF_SLASH$1 = /~1/g; +const ESCAPED_REF_TILDE$1 = /~0/g; +const getRef$1 = (openApi, item) => { + if (item.$ref) { + // Fetch the paths to the definitions, this converts: + // "#/definitions/Form" to ["definitions", "Form"] + const paths = item.$ref + .replace(/^#/g, '') + .split('/') + .filter(item => item); + // Try to find the reference by walking down the path, + // if we cannot find it, then we throw an error. + let result = openApi; + paths.forEach(path => { + const decodedPath = decodeURIComponent(path.replace(ESCAPED_REF_SLASH$1, '/').replace(ESCAPED_REF_TILDE$1, '~')); + if (result.hasOwnProperty(decodedPath)) { + result = result[decodedPath]; + } + else { + throw new Error(`Could not find reference: "${item.$ref}"`); + } + }); + return result; + } + return item; +}; + +const getRequiredPropertiesFromComposition$1 = (openApi, required, definitions, getModel) => { + return definitions + .reduce((properties, definition) => { + if (definition.$ref) { + const schema = getRef$1(openApi, definition); + return [...properties, ...getModel(openApi, schema).properties]; + } + return [...properties, ...getModel(openApi, definition).properties]; + }, []) + .filter(property => { + return !property.isRequired && required.includes(property.name); + }) + .map(property => { + return { + ...property, + isRequired: true, + }; + }); +}; + +const getModelComposition$1 = (openApi, definition, definitions, type, getModel) => { + const composition = { + type, + imports: [], + enums: [], + properties: [], + }; + const properties = []; + definitions + .map(definition => getModel(openApi, definition)) + .filter(model => { + const hasProperties = model.properties.length; + const hasEnums = model.enums.length; + const isObject = model.type === 'any'; + const isEmpty = isObject && !hasProperties && !hasEnums; + return !isEmpty; + }) + .forEach(model => { + composition.imports.push(...model.imports); + composition.enums.push(...model.enums); + composition.properties.push(model); + }); + if (definition.required) { + const requiredProperties = getRequiredPropertiesFromComposition$1(openApi, definition.required, definitions, getModel); + requiredProperties.forEach(requiredProperty => { + composition.imports.push(...requiredProperty.imports); + composition.enums.push(...requiredProperty.enums); + }); + properties.push(...requiredProperties); + } + if (definition.properties) { + const modelProperties = getModelProperties$1(openApi, definition, getModel); + modelProperties.forEach(modelProperty => { + composition.imports.push(...modelProperty.imports); + composition.enums.push(...modelProperty.enums); + if (modelProperty.export === 'enum') { + composition.enums.push(modelProperty); + } + }); + properties.push(...modelProperties); + } + if (properties.length) { + composition.properties.push({ + name: 'properties', + export: 'interface', + type: 'any', + base: 'any', + template: null, + link: null, + description: '', + isDefinition: false, + isReadOnly: false, + isNullable: false, + isRequired: false, + imports: [], + enum: [], + enums: [], + properties, + }); + } + return composition; +}; + +const getModel$1 = (openApi, definition, isDefinition = false, name = '') => { + var _a; + const model = { + name, + export: 'interface', + type: 'any', + base: 'any', + template: null, + link: null, + description: definition.description || null, + isDefinition, + isReadOnly: definition.readOnly === true, + isNullable: definition['x-nullable'] === true, + isRequired: false, + format: definition.format, + maximum: definition.maximum, + exclusiveMaximum: definition.exclusiveMaximum, + minimum: definition.minimum, + exclusiveMinimum: definition.exclusiveMinimum, + multipleOf: definition.multipleOf, + maxLength: definition.maxLength, + minLength: definition.minLength, + maxItems: definition.maxItems, + minItems: definition.minItems, + uniqueItems: definition.uniqueItems, + maxProperties: definition.maxProperties, + minProperties: definition.minProperties, + pattern: getPattern(definition.pattern), + imports: [], + enum: [], + enums: [], + properties: [], + }; + if (definition.$ref) { + const definitionRef = getType$1(definition.$ref); + model.export = 'reference'; + model.type = definitionRef.type; + model.base = definitionRef.base; + model.template = definitionRef.template; + model.imports.push(...definitionRef.imports); + return model; + } + if (definition.enum && definition.type !== 'boolean') { + const enumerators = getEnum$1(definition.enum); + const extendedEnumerators = extendEnum$1(enumerators, definition); + if (extendedEnumerators.length) { + model.export = 'enum'; + model.type = 'string'; + model.base = 'string'; + model.enum.push(...extendedEnumerators); + return model; + } + } + if (definition.type === 'array' && definition.items) { + if (definition.items.$ref) { + const arrayItems = getType$1(definition.items.$ref); + model.export = 'array'; + model.type = arrayItems.type; + model.base = arrayItems.base; + model.template = arrayItems.template; + model.imports.push(...arrayItems.imports); + return model; + } + else { + const arrayItems = getModel$1(openApi, definition.items); + model.export = 'array'; + model.type = arrayItems.type; + model.base = arrayItems.base; + model.template = arrayItems.template; + model.link = arrayItems; + model.imports.push(...arrayItems.imports); + return model; + } + } + if (definition.type === 'object' && typeof definition.additionalProperties === 'object') { + if (definition.additionalProperties.$ref) { + const additionalProperties = getType$1(definition.additionalProperties.$ref); + model.export = 'dictionary'; + model.type = additionalProperties.type; + model.base = additionalProperties.base; + model.template = additionalProperties.template; + model.imports.push(...additionalProperties.imports); + return model; + } + else { + const additionalProperties = getModel$1(openApi, definition.additionalProperties); + model.export = 'dictionary'; + model.type = additionalProperties.type; + model.base = additionalProperties.base; + model.template = additionalProperties.template; + model.link = additionalProperties; + model.imports.push(...additionalProperties.imports); + return model; + } + } + if ((_a = definition.allOf) === null || _a === void 0 ? void 0 : _a.length) { + const composition = getModelComposition$1(openApi, definition, definition.allOf, 'all-of', getModel$1); + model.export = composition.type; + model.imports.push(...composition.imports); + model.properties.push(...composition.properties); + model.enums.push(...composition.enums); + return model; + } + if (definition.type === 'object') { + model.export = 'interface'; + model.type = 'any'; + model.base = 'any'; + if (definition.properties) { + const modelProperties = getModelProperties$1(openApi, definition, getModel$1); + modelProperties.forEach(modelProperty => { + model.imports.push(...modelProperty.imports); + model.enums.push(...modelProperty.enums); + model.properties.push(modelProperty); + if (modelProperty.export === 'enum') { + model.enums.push(modelProperty); + } + }); + } + return model; + } + // If the schema has a type than it can be a basic or generic type. + if (definition.type) { + const definitionType = getType$1(definition.type, definition.format); + model.export = 'generic'; + model.type = definitionType.type; + model.base = definitionType.base; + model.template = definitionType.template; + model.imports.push(...definitionType.imports); + return model; + } + return model; +}; + +const getModels$1 = (openApi) => { + const models = []; + for (const definitionName in openApi.definitions) { + if (openApi.definitions.hasOwnProperty(definitionName)) { + const definition = openApi.definitions[definitionName]; + const definitionType = getType$1(definitionName); + const model = getModel$1(openApi, definition, true, definitionType.base.replace(reservedWords$1, '_$1')); + models.push(model); + } + } + return models; +}; + +/** + * Get the base server url. + * @param openApi + */ +const getServer$1 = (openApi) => { + var _a; + const scheme = ((_a = openApi.schemes) === null || _a === void 0 ? void 0 : _a[0]) || 'http'; + const host = openApi.host; + const basePath = openApi.basePath || ''; + const url = host ? `${scheme}://${host}${basePath}` : basePath; + return url.replace(/\/$/g, ''); +}; + +const unique = (val, index, arr) => { + return arr.indexOf(val) === index; +}; + +/** + * + * @param operationResponses + */ +const getOperationErrors$1 = (operationResponses) => { + return operationResponses + .filter(operationResponse => { + return operationResponse.code >= 300 && operationResponse.description; + }) + .map(response => ({ + code: response.code, + description: response.description, + })); +}; + +/** + * Convert the input value to a correct operation (method) classname. + * This will use the operation ID - if available - and otherwise fallback + * on a generated name from the URL + */ +const getOperationName$1 = (url, method, operationId) => { + if (operationId) { + return camelCase(operationId + .replace(/^[^a-zA-Z]+/g, '') + .replace(/[^\w\-]+/g, '-') + .trim()); + } + const urlWithoutPlaceholders = url + .replace(/[^/]*?{api-version}.*?\//g, '') + .replace(/{(.*?)}/g, '') + .replace(/\//g, '-'); + return camelCase(`${method}-${urlWithoutPlaceholders}`); +}; + +const getOperationParameterDefault = (parameter, operationParameter) => { + var _a; + if (parameter.default === undefined) { + return undefined; + } + if (parameter.default === null) { + return 'null'; + } + const type = parameter.type || typeof parameter.default; + switch (type) { + case 'int': + case 'integer': + case 'number': + if (operationParameter.export === 'enum' && ((_a = operationParameter.enum) === null || _a === void 0 ? void 0 : _a[parameter.default])) { + return operationParameter.enum[parameter.default].value; + } + return parameter.default; + case 'boolean': + return JSON.stringify(parameter.default); + case 'string': + return `'${parameter.default}'`; + case 'object': + try { + return JSON.stringify(parameter.default, null, 4); + } + catch (e) { + // Ignore + } + } + return undefined; +}; + +const reservedWords = /^(arguments|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|eval|export|extends|false|finally|for|function|if|implements|import|in|instanceof|interface|let|new|null|package|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)$/g; +/** + * Replaces any invalid characters from a parameter name. + * For example: 'filter.someProperty' becomes 'filterSomeProperty'. + */ +const getOperationParameterName = (value) => { + const clean = value + .replace(/^[^a-zA-Z]+/g, '') + .replace(/[^\w\-]+/g, '-') + .trim(); + return camelCase(clean).replace(reservedWords, '_$1'); +}; + +const getOperationParameter$1 = (openApi, parameter) => { + var _a; + const operationParameter = { + in: parameter.in, + prop: parameter.name, + export: 'interface', + name: getOperationParameterName(parameter.name), + type: 'any', + base: 'any', + template: null, + link: null, + description: parameter.description || null, + isDefinition: false, + isReadOnly: false, + isRequired: parameter.required === true, + isNullable: parameter['x-nullable'] === true, + format: parameter.format, + maximum: parameter.maximum, + exclusiveMaximum: parameter.exclusiveMaximum, + minimum: parameter.minimum, + exclusiveMinimum: parameter.exclusiveMinimum, + multipleOf: parameter.multipleOf, + maxLength: parameter.maxLength, + minLength: parameter.minLength, + maxItems: parameter.maxItems, + minItems: parameter.minItems, + uniqueItems: parameter.uniqueItems, + pattern: getPattern(parameter.pattern), + imports: [], + enum: [], + enums: [], + properties: [], + mediaType: null, + }; + if (parameter.$ref) { + const definitionRef = getType$1(parameter.$ref); + operationParameter.export = 'reference'; + operationParameter.type = definitionRef.type; + operationParameter.base = definitionRef.base; + operationParameter.template = definitionRef.template; + operationParameter.imports.push(...definitionRef.imports); + operationParameter.default = getOperationParameterDefault(parameter, operationParameter); + return operationParameter; + } + if (parameter.enum) { + const enumerators = getEnum$1(parameter.enum); + const extendedEnumerators = extendEnum$1(enumerators, parameter); + if (extendedEnumerators.length) { + operationParameter.export = 'enum'; + operationParameter.type = 'string'; + operationParameter.base = 'string'; + operationParameter.enum.push(...extendedEnumerators); + operationParameter.default = getOperationParameterDefault(parameter, operationParameter); + return operationParameter; + } + } + if (parameter.type === 'array' && parameter.items) { + const items = getType$1(parameter.items.type, parameter.items.format); + operationParameter.export = 'array'; + operationParameter.type = items.type; + operationParameter.base = items.base; + operationParameter.template = items.template; + operationParameter.imports.push(...items.imports); + operationParameter.default = getOperationParameterDefault(parameter, operationParameter); + return operationParameter; + } + if (parameter.type === 'object' && parameter.items) { + const items = getType$1(parameter.items.type, parameter.items.format); + operationParameter.export = 'dictionary'; + operationParameter.type = items.type; + operationParameter.base = items.base; + operationParameter.template = items.template; + operationParameter.imports.push(...items.imports); + operationParameter.default = getOperationParameterDefault(parameter, operationParameter); + return operationParameter; + } + let schema = parameter.schema; + if (schema) { + if ((_a = schema.$ref) === null || _a === void 0 ? void 0 : _a.startsWith('#/parameters/')) { + schema = getRef$1(openApi, schema); + } + if (schema.$ref) { + const model = getType$1(schema.$ref); + operationParameter.export = 'reference'; + operationParameter.type = model.type; + operationParameter.base = model.base; + operationParameter.template = model.template; + operationParameter.imports.push(...model.imports); + operationParameter.default = getOperationParameterDefault(parameter, operationParameter); + return operationParameter; + } + else { + const model = getModel$1(openApi, schema); + operationParameter.export = model.export; + operationParameter.type = model.type; + operationParameter.base = model.base; + operationParameter.template = model.template; + operationParameter.link = model.link; + operationParameter.imports.push(...model.imports); + operationParameter.enum.push(...model.enum); + operationParameter.enums.push(...model.enums); + operationParameter.properties.push(...model.properties); + operationParameter.default = getOperationParameterDefault(parameter, operationParameter); + return operationParameter; + } + } + // If the parameter has a type than it can be a basic or generic type. + if (parameter.type) { + const definitionType = getType$1(parameter.type, parameter.format); + operationParameter.export = 'generic'; + operationParameter.type = definitionType.type; + operationParameter.base = definitionType.base; + operationParameter.template = definitionType.template; + operationParameter.imports.push(...definitionType.imports); + operationParameter.default = getOperationParameterDefault(parameter, operationParameter); + return operationParameter; + } + return operationParameter; +}; + +const getOperationParameters$1 = (openApi, parameters) => { + const operationParameters = { + imports: [], + parameters: [], + parametersPath: [], + parametersQuery: [], + parametersForm: [], + parametersCookie: [], + parametersHeader: [], + parametersBody: null, + }; + // Iterate over the parameters + parameters.forEach(parameterOrReference => { + const parameterDef = getRef$1(openApi, parameterOrReference); + const parameter = getOperationParameter$1(openApi, parameterDef); + // We ignore the "api-version" param, since we do not want to add this + // as the first / default parameter for each of the service calls. + if (parameter.prop !== 'api-version') { + switch (parameter.in) { + case 'path': + operationParameters.parametersPath.push(parameter); + operationParameters.parameters.push(parameter); + operationParameters.imports.push(...parameter.imports); + break; + case 'query': + operationParameters.parametersQuery.push(parameter); + operationParameters.parameters.push(parameter); + operationParameters.imports.push(...parameter.imports); + break; + case 'header': + operationParameters.parametersHeader.push(parameter); + operationParameters.parameters.push(parameter); + operationParameters.imports.push(...parameter.imports); + break; + case 'formData': + operationParameters.parametersForm.push(parameter); + operationParameters.parameters.push(parameter); + operationParameters.imports.push(...parameter.imports); + break; + case 'body': + operationParameters.parametersBody = parameter; + operationParameters.parameters.push(parameter); + operationParameters.imports.push(...parameter.imports); + break; + } + } + }); + return operationParameters; +}; + +const getOperationResponseHeader$1 = (operationResponses) => { + const header = operationResponses.find(operationResponses => { + return operationResponses.in === 'header'; + }); + if (header) { + return header.name; + } + return null; +}; + +const getOperationResponse$1 = (openApi, response, responseCode) => { + var _a; + const operationResponse = { + in: 'response', + name: '', + code: responseCode, + description: response.description || null, + export: 'generic', + type: 'any', + base: 'any', + template: null, + link: null, + isDefinition: false, + isReadOnly: false, + isRequired: false, + isNullable: false, + imports: [], + enum: [], + enums: [], + properties: [], + }; + // If this response has a schema, then we need to check two things: + // if this is a reference then the parameter is just the 'name' of + // this reference type. Otherwise, it might be a complex schema, + // and then we need to parse the schema! + let schema = response.schema; + if (schema) { + if ((_a = schema.$ref) === null || _a === void 0 ? void 0 : _a.startsWith('#/responses/')) { + schema = getRef$1(openApi, schema); + } + if (schema.$ref) { + const model = getType$1(schema.$ref); + operationResponse.export = 'reference'; + operationResponse.type = model.type; + operationResponse.base = model.base; + operationResponse.template = model.template; + operationResponse.imports.push(...model.imports); + return operationResponse; + } + else { + const model = getModel$1(openApi, schema); + operationResponse.export = model.export; + operationResponse.type = model.type; + operationResponse.base = model.base; + operationResponse.template = model.template; + operationResponse.link = model.link; + operationResponse.isReadOnly = model.isReadOnly; + operationResponse.isRequired = model.isRequired; + operationResponse.isNullable = model.isNullable; + operationResponse.format = model.format; + operationResponse.maximum = model.maximum; + operationResponse.exclusiveMaximum = model.exclusiveMaximum; + operationResponse.minimum = model.minimum; + operationResponse.exclusiveMinimum = model.exclusiveMinimum; + operationResponse.multipleOf = model.multipleOf; + operationResponse.maxLength = model.maxLength; + operationResponse.minLength = model.minLength; + operationResponse.maxItems = model.maxItems; + operationResponse.minItems = model.minItems; + operationResponse.uniqueItems = model.uniqueItems; + operationResponse.maxProperties = model.maxProperties; + operationResponse.minProperties = model.minProperties; + operationResponse.pattern = getPattern(model.pattern); + operationResponse.imports.push(...model.imports); + operationResponse.enum.push(...model.enum); + operationResponse.enums.push(...model.enums); + operationResponse.properties.push(...model.properties); + return operationResponse; + } + } + // We support basic properties from response headers, since both + // fetch and XHR client just support string types. + if (response.headers) { + for (const name in response.headers) { + if (response.headers.hasOwnProperty(name)) { + operationResponse.in = 'header'; + operationResponse.name = name; + operationResponse.type = 'string'; + operationResponse.base = 'string'; + return operationResponse; + } + } + } + return operationResponse; +}; + +const getOperationResponseCode$1 = (value) => { + // You can specify a "default" response, this is treated as HTTP code 200 + if (value === 'default') { + return 200; + } + // Check if we can parse the code and return of successful. + if (/[0-9]+/g.test(value)) { + const code = parseInt(value); + if (Number.isInteger(code)) { + return Math.abs(code); + } + } + return null; +}; + +const getOperationResponses$1 = (openApi, responses) => { + const operationResponses = []; + // Iterate over each response code and get the + // status code and response message (if any). + for (const code in responses) { + if (responses.hasOwnProperty(code)) { + const responseOrReference = responses[code]; + const response = getRef$1(openApi, responseOrReference); + const responseCode = getOperationResponseCode$1(code); + if (responseCode) { + const operationResponse = getOperationResponse$1(openApi, response, responseCode); + operationResponses.push(operationResponse); + } + } + } + // Sort the responses to 2XX success codes come before 4XX and 5XX error codes. + return operationResponses.sort((a, b) => { + return a.code < b.code ? -1 : a.code > b.code ? 1 : 0; + }); +}; + +const areEqual$1 = (a, b) => { + const equal = a.type === b.type && a.base === b.base && a.template === b.template; + if (equal && a.link && b.link) { + return areEqual$1(a.link, b.link); + } + return equal; +}; +const getOperationResults$1 = (operationResponses) => { + const operationResults = []; + // Filter out success response codes, but skip "204 No Content" + operationResponses.forEach(operationResponse => { + const { code } = operationResponse; + if (code && code !== 204 && code >= 200 && code < 300) { + operationResults.push(operationResponse); + } + }); + if (!operationResults.length) { + operationResults.push({ + in: 'response', + name: '', + code: 200, + description: '', + export: 'generic', + type: 'void', + base: 'void', + template: null, + link: null, + isDefinition: false, + isReadOnly: false, + isRequired: false, + isNullable: false, + imports: [], + enum: [], + enums: [], + properties: [], + }); + } + return operationResults.filter((operationResult, index, arr) => { + return (arr.findIndex(item => { + return areEqual$1(item, operationResult); + }) === index); + }); +}; + +/** + * Convert the input value to a correct service name. This converts + * the input string to PascalCase. + */ +const getServiceName$1 = (value) => { + const clean = value + .replace(/^[^a-zA-Z]+/g, '') + .replace(/[^\w\-]+/g, '-') + .trim(); + return camelCase(clean, { pascalCase: true }); +}; + +const sortByRequired$1 = (a, b) => { + const aNeedsValue = a.isRequired && a.default === undefined; + const bNeedsValue = b.isRequired && b.default === undefined; + if (aNeedsValue && !bNeedsValue) + return -1; + if (bNeedsValue && !aNeedsValue) + return 1; + return 0; +}; + +const getOperation$1 = (openApi, url, method, tag, op, pathParams) => { + const serviceName = getServiceName$1(tag); + const operationName = getOperationName$1(url, method, op.operationId); + // Create a new operation object for this method. + const operation = { + service: serviceName, + name: operationName, + summary: op.summary || null, + description: op.description || null, + deprecated: op.deprecated === true, + method: method.toUpperCase(), + path: url, + parameters: [...pathParams.parameters], + parametersPath: [...pathParams.parametersPath], + parametersQuery: [...pathParams.parametersQuery], + parametersForm: [...pathParams.parametersForm], + parametersHeader: [...pathParams.parametersHeader], + parametersCookie: [...pathParams.parametersCookie], + parametersBody: pathParams.parametersBody, + imports: [], + errors: [], + results: [], + responseHeader: null, + }; + // Parse the operation parameters (path, query, body, etc). + if (op.parameters) { + const parameters = getOperationParameters$1(openApi, op.parameters); + operation.imports.push(...parameters.imports); + operation.parameters.push(...parameters.parameters); + operation.parametersPath.push(...parameters.parametersPath); + operation.parametersQuery.push(...parameters.parametersQuery); + operation.parametersForm.push(...parameters.parametersForm); + operation.parametersHeader.push(...parameters.parametersHeader); + operation.parametersCookie.push(...parameters.parametersCookie); + operation.parametersBody = parameters.parametersBody; + } + // Parse the operation responses. + if (op.responses) { + const operationResponses = getOperationResponses$1(openApi, op.responses); + const operationResults = getOperationResults$1(operationResponses); + operation.errors = getOperationErrors$1(operationResponses); + operation.responseHeader = getOperationResponseHeader$1(operationResults); + operationResults.forEach(operationResult => { + operation.results.push(operationResult); + operation.imports.push(...operationResult.imports); + }); + } + operation.parameters = operation.parameters.sort(sortByRequired$1); + return operation; +}; + +/** + * Get the OpenAPI services + */ +const getServices$1 = (openApi) => { + var _a; + const services = new Map(); + for (const url in openApi.paths) { + if (openApi.paths.hasOwnProperty(url)) { + // Grab path and parse any global path parameters + const path = openApi.paths[url]; + const pathParams = getOperationParameters$1(openApi, path.parameters || []); + // Parse all the methods for this path + for (const method in path) { + if (path.hasOwnProperty(method)) { + switch (method) { + case 'get': + case 'put': + case 'post': + case 'delete': + case 'options': + case 'head': + case 'patch': + // Each method contains an OpenAPI operation, we parse the operation + const op = path[method]; + const tags = ((_a = op.tags) === null || _a === void 0 ? void 0 : _a.length) ? op.tags.filter(unique) : ['Default']; + tags.forEach(tag => { + const operation = getOperation$1(openApi, url, method, tag, op, pathParams); + // If we have already declared a service, then we should fetch that and + // append the new method to it. Otherwise we should create a new service object. + const service = services.get(operation.service) || { + name: operation.service, + operations: [], + imports: [], + }; + // Push the operation in the service + service.operations.push(operation); + service.imports.push(...operation.imports); + services.set(operation.service, service); + }); + break; + } + } + } + } + } + return Array.from(services.values()); +}; + +/** + * Convert the service version to 'normal' version. + * This basically removes any "v" prefix from the version string. + * @param version + */ +const getServiceVersion$1 = (version = '1.0') => { + return String(version).replace(/^v/gi, ''); +}; + +/** + * Parse the OpenAPI specification to a Client model that contains + * all the models, services and schema's we should output. + * @param openApi The OpenAPI spec that we have loaded from disk. + */ +const parse$1 = (openApi) => { + const version = getServiceVersion$1(openApi.info.version); + const server = getServer$1(openApi); + const models = getModels$1(openApi); + const services = getServices$1(openApi); + return { version, server, models, services }; +}; + +/** + * Extend the enum with the x-enum properties. This adds the capability + * to use names and descriptions inside the generated enums. + * @param enumerators + * @param definition + */ +const extendEnum = (enumerators, definition) => { + var _a, _b; + const names = (_a = definition['x-enum-varnames']) === null || _a === void 0 ? void 0 : _a.filter(isString); + const descriptions = (_b = definition['x-enum-descriptions']) === null || _b === void 0 ? void 0 : _b.filter(isString); + return enumerators.map((enumerator, index) => ({ + name: (names === null || names === void 0 ? void 0 : names[index]) || enumerator.name, + description: (descriptions === null || descriptions === void 0 ? void 0 : descriptions[index]) || enumerator.description, + value: enumerator.value, + type: enumerator.type, + })); +}; + +const getEnum = (values) => { + if (Array.isArray(values)) { + return values + .filter((value, index, arr) => { + return arr.indexOf(value) === index; + }) + .filter((value) => { + return typeof value === 'number' || typeof value === 'string'; + }) + .map(value => { + if (typeof value === 'number') { + return { + name: `'_${value}'`, + value: String(value), + type: 'number', + description: null, + }; + } + return { + name: String(value) + .replace(/\W+/g, '_') + .replace(/^(\d+)/g, '_$1') + .replace(/([a-z])([A-Z]+)/g, '$1_$2') + .toUpperCase(), + value: `'${value.replace(/'/g, "\\'")}'`, + type: 'string', + description: null, + }; + }); + } + return []; +}; + +/** + * Strip (OpenAPI) namespaces fom values. + * @param value + */ +const stripNamespace = (value) => { + return value + .trim() + .replace(/^#\/components\/schemas\//, '') + .replace(/^#\/components\/responses\//, '') + .replace(/^#\/components\/parameters\//, '') + .replace(/^#\/components\/examples\//, '') + .replace(/^#\/components\/requestBodies\//, '') + .replace(/^#\/components\/headers\//, '') + .replace(/^#\/components\/securitySchemes\//, '') + .replace(/^#\/components\/links\//, '') + .replace(/^#\/components\/callbacks\//, ''); +}; + +const inverseDictionary = (map) => { + const m2 = {}; + for (const key in map) { + m2[map[key]] = key; + } + return m2; +}; +const findOneOfParentDiscriminator = (openApi, parent) => { + var _a; + if (openApi.components && parent) { + for (const definitionName in openApi.components.schemas) { + if (openApi.components.schemas.hasOwnProperty(definitionName)) { + const schema = openApi.components.schemas[definitionName]; + if (schema.discriminator && + ((_a = schema.oneOf) === null || _a === void 0 ? void 0 : _a.length) && + schema.oneOf.some(definition => definition.$ref && stripNamespace(definition.$ref) == parent.name)) { + return schema.discriminator; + } + } + } + } + return undefined; +}; +const mapPropertyValue = (discriminator, parent) => { + if (discriminator.mapping) { + const mapping = inverseDictionary(discriminator.mapping); + const key = Object.keys(mapping).find(item => stripNamespace(item) == parent.name); + if (key && mapping[key]) { + return mapping[key]; + } + } + return parent.name; +}; + +const escapeName = (value) => { + if (value || value === '') { + const validName = /^[a-zA-Z_$][\w$]+$/g.test(value); + if (!validName) { + return `'${value}'`; + } + } + return value; +}; + +/** + * Check if a value is defined + * @param value + */ +const isDefined = (value) => { + return value !== undefined && value !== null && value !== ''; +}; + +const TYPE_MAPPINGS = new Map([ + ['file', 'binary'], + ['any', 'any'], + ['object', 'any'], + ['array', 'any[]'], + ['boolean', 'boolean'], + ['byte', 'number'], + ['int', 'number'], + ['integer', 'number'], + ['float', 'number'], + ['double', 'number'], + ['short', 'number'], + ['long', 'number'], + ['number', 'number'], + ['char', 'string'], + ['date', 'string'], + ['date-time', 'string'], + ['password', 'string'], + ['string', 'string'], + ['void', 'void'], + ['null', 'null'], +]); +/** + * Get mapped type for given type to any basic Typescript/Javascript type. + */ +const getMappedType = (type, format) => { + if (format === 'binary') { + return 'binary'; + } + return TYPE_MAPPINGS.get(type); +}; + +const encode = (value) => { + return value.replace(/^[^a-zA-Z_$]+/g, '').replace(/[^\w$]+/g, '_'); +}; +/** + * Parse any string value into a type object. + * @param type String or String[] value like "integer", "Link[Model]" or ["string", "null"]. + * @param format String value like "binary" or "date". + */ +const getType = (type = 'any', format) => { + const result = { + type: 'any', + base: 'any', + template: null, + imports: [], + isNullable: false, + }; + // Special case for JSON Schema spec (december 2020, page 17), + // that allows type to be an array of primitive types... + if (Array.isArray(type)) { + const joinedType = type + .filter(value => value !== 'null') + .map(value => getMappedType(value, format)) + .filter(isDefined) + .join(' | '); + result.type = joinedType; + result.base = joinedType; + result.isNullable = type.includes('null'); + return result; + } + const mapped = getMappedType(type, format); + if (mapped) { + result.type = mapped; + result.base = mapped; + return result; + } + const typeWithoutNamespace = decodeURIComponent(stripNamespace(type)); + if (/\[.*\]$/g.test(typeWithoutNamespace)) { + const matches = typeWithoutNamespace.match(/(.*?)\[(.*)\]$/); + if (matches === null || matches === void 0 ? void 0 : matches.length) { + const match1 = getType(encode(matches[1])); + const match2 = getType(encode(matches[2])); + if (match1.type === 'any[]') { + result.type = `${match2.type}[]`; + result.base = `${match2.type}`; + match1.imports = []; + } + else if (match2.type) { + result.type = `${match1.type}<${match2.type}>`; + result.base = match1.type; + result.template = match2.type; + } + else { + result.type = match1.type; + result.base = match1.type; + result.template = match1.type; + } + result.imports.push(...match1.imports); + result.imports.push(...match2.imports); + return result; + } + } + if (typeWithoutNamespace) { + const type = encode(typeWithoutNamespace); + result.type = type; + result.base = type; + result.imports.push(type); + return result; + } + return result; +}; + +const getModelProperties = (openApi, definition, getModel, parent) => { + var _a; + const models = []; + const discriminator = findOneOfParentDiscriminator(openApi, parent); + for (const propertyName in definition.properties) { + if (definition.properties.hasOwnProperty(propertyName)) { + const property = definition.properties[propertyName]; + const propertyRequired = !!((_a = definition.required) === null || _a === void 0 ? void 0 : _a.includes(propertyName)); + const propertyValues = { + name: escapeName(propertyName), + description: property.description || null, + deprecated: property.deprecated === true, + isDefinition: false, + isReadOnly: property.readOnly === true, + isRequired: propertyRequired, + format: property.format, + maximum: property.maximum, + exclusiveMaximum: property.exclusiveMaximum, + minimum: property.minimum, + exclusiveMinimum: property.exclusiveMinimum, + multipleOf: property.multipleOf, + maxLength: property.maxLength, + minLength: property.minLength, + maxItems: property.maxItems, + minItems: property.minItems, + uniqueItems: property.uniqueItems, + maxProperties: property.maxProperties, + minProperties: property.minProperties, + pattern: getPattern(property.pattern), + }; + if (parent && (discriminator === null || discriminator === void 0 ? void 0 : discriminator.propertyName) == propertyName) { + models.push({ + export: 'reference', + type: 'string', + base: `'${mapPropertyValue(discriminator, parent)}'`, + template: null, + isNullable: property.nullable === true, + link: null, + imports: [], + enum: [], + enums: [], + properties: [], + ...propertyValues, + }); + } + else if (property.$ref) { + const model = getType(property.$ref); + models.push({ + export: 'reference', + type: model.type, + base: model.base, + template: model.template, + link: null, + isNullable: model.isNullable || property.nullable === true, + imports: model.imports, + enum: [], + enums: [], + properties: [], + ...propertyValues, + }); + } + else { + const model = getModel(openApi, property); + models.push({ + export: model.export, + type: model.type, + base: model.base, + template: model.template, + link: model.link, + isNullable: model.isNullable || property.nullable === true, + imports: model.imports, + enum: model.enum, + enums: model.enums, + properties: model.properties, + ...propertyValues, + }); + } + } + } + return models; +}; + +const ESCAPED_REF_SLASH = /~1/g; +const ESCAPED_REF_TILDE = /~0/g; +const getRef = (openApi, item) => { + if (item.$ref) { + // Fetch the paths to the definitions, this converts: + // "#/components/schemas/Form" to ["components", "schemas", "Form"] + const paths = item.$ref + .replace(/^#/g, '') + .split('/') + .filter(item => item); + // Try to find the reference by walking down the path, + // if we cannot find it, then we throw an error. + let result = openApi; + paths.forEach(path => { + const decodedPath = decodeURIComponent(path.replace(ESCAPED_REF_SLASH, '/').replace(ESCAPED_REF_TILDE, '~')); + if (result.hasOwnProperty(decodedPath)) { + result = result[decodedPath]; + } + else { + throw new Error(`Could not find reference: "${item.$ref}"`); + } + }); + return result; + } + return item; +}; + +const getRequiredPropertiesFromComposition = (openApi, required, definitions, getModel) => { + return definitions + .reduce((properties, definition) => { + if (definition.$ref) { + const schema = getRef(openApi, definition); + return [...properties, ...getModel(openApi, schema).properties]; + } + return [...properties, ...getModel(openApi, definition).properties]; + }, []) + .filter(property => { + return !property.isRequired && required.includes(property.name); + }) + .map(property => { + return { + ...property, + isRequired: true, + }; + }); +}; + +const getModelComposition = (openApi, definition, definitions, type, getModel) => { + const composition = { + type, + imports: [], + enums: [], + properties: [], + }; + const properties = []; + definitions + .map(definition => getModel(openApi, definition)) + .filter(model => { + const hasProperties = model.properties.length; + const hasEnums = model.enums.length; + const isObject = model.type === 'any'; + const isDictionary = model.export === 'dictionary'; + const isEmpty = isObject && !hasProperties && !hasEnums; + return !isEmpty || isDictionary; + }) + .forEach(model => { + composition.imports.push(...model.imports); + composition.enums.push(...model.enums); + composition.properties.push(model); + }); + if (definition.required) { + const requiredProperties = getRequiredPropertiesFromComposition(openApi, definition.required, definitions, getModel); + requiredProperties.forEach(requiredProperty => { + composition.imports.push(...requiredProperty.imports); + composition.enums.push(...requiredProperty.enums); + }); + properties.push(...requiredProperties); + } + if (definition.properties) { + const modelProperties = getModelProperties(openApi, definition, getModel); + modelProperties.forEach(modelProperty => { + composition.imports.push(...modelProperty.imports); + composition.enums.push(...modelProperty.enums); + if (modelProperty.export === 'enum') { + composition.enums.push(modelProperty); + } + }); + properties.push(...modelProperties); + } + if (properties.length) { + composition.properties.push({ + name: 'properties', + export: 'interface', + type: 'any', + base: 'any', + template: null, + link: null, + description: '', + isDefinition: false, + isReadOnly: false, + isNullable: false, + isRequired: false, + imports: [], + enum: [], + enums: [], + properties, + }); + } + return composition; +}; + +const getModelDefault = (definition, model) => { + var _a; + if (definition.default === undefined) { + return undefined; + } + if (definition.default === null) { + return 'null'; + } + const type = definition.type || typeof definition.default; + switch (type) { + case 'int': + case 'integer': + case 'number': + if ((model === null || model === void 0 ? void 0 : model.export) === 'enum' && ((_a = model.enum) === null || _a === void 0 ? void 0 : _a[definition.default])) { + return model.enum[definition.default].value; + } + return definition.default; + case 'boolean': + return JSON.stringify(definition.default); + case 'string': + return `'${definition.default}'`; + case 'object': + try { + return JSON.stringify(definition.default, null, 4); + } + catch (e) { + // Ignore + } + } + return undefined; +}; + +const getModel = (openApi, definition, isDefinition = false, name = '') => { + var _a, _b, _c; + const model = { + name, + export: 'interface', + type: 'any', + base: 'any', + template: null, + link: null, + description: definition.description || null, + deprecated: definition.deprecated === true, + isDefinition, + isReadOnly: definition.readOnly === true, + isNullable: definition.nullable === true, + isRequired: false, + format: definition.format, + maximum: definition.maximum, + exclusiveMaximum: definition.exclusiveMaximum, + minimum: definition.minimum, + exclusiveMinimum: definition.exclusiveMinimum, + multipleOf: definition.multipleOf, + maxLength: definition.maxLength, + minLength: definition.minLength, + maxItems: definition.maxItems, + minItems: definition.minItems, + uniqueItems: definition.uniqueItems, + maxProperties: definition.maxProperties, + minProperties: definition.minProperties, + pattern: getPattern(definition.pattern), + imports: [], + enum: [], + enums: [], + properties: [], + }; + if (definition.$ref) { + const definitionRef = getType(definition.$ref); + model.export = 'reference'; + model.type = definitionRef.type; + model.base = definitionRef.base; + model.template = definitionRef.template; + model.imports.push(...definitionRef.imports); + model.default = getModelDefault(definition, model); + return model; + } + if (definition.enum && definition.type !== 'boolean') { + const enumerators = getEnum(definition.enum); + const extendedEnumerators = extendEnum(enumerators, definition); + if (extendedEnumerators.length) { + model.export = 'enum'; + model.type = 'string'; + model.base = 'string'; + model.enum.push(...extendedEnumerators); + model.default = getModelDefault(definition, model); + return model; + } + } + if (definition.type === 'array' && definition.items) { + if (definition.items.$ref) { + const arrayItems = getType(definition.items.$ref); + model.export = 'array'; + model.type = arrayItems.type; + model.base = arrayItems.base; + model.template = arrayItems.template; + model.imports.push(...arrayItems.imports); + model.default = getModelDefault(definition, model); + return model; + } + else { + const arrayItems = getModel(openApi, definition.items); + model.export = 'array'; + model.type = arrayItems.type; + model.base = arrayItems.base; + model.template = arrayItems.template; + model.link = arrayItems; + model.imports.push(...arrayItems.imports); + model.default = getModelDefault(definition, model); + return model; + } + } + if (definition.type === 'object' && + (typeof definition.additionalProperties === 'object' || definition.additionalProperties === true)) { + const ap = typeof definition.additionalProperties === 'object' ? definition.additionalProperties : {}; + if (ap.$ref) { + const additionalProperties = getType(ap.$ref); + model.export = 'dictionary'; + model.type = additionalProperties.type; + model.base = additionalProperties.base; + model.template = additionalProperties.template; + model.imports.push(...additionalProperties.imports); + model.default = getModelDefault(definition, model); + return model; + } + else { + const additionalProperties = getModel(openApi, ap); + model.export = 'dictionary'; + model.type = additionalProperties.type; + model.base = additionalProperties.base; + model.template = additionalProperties.template; + model.link = additionalProperties; + model.imports.push(...additionalProperties.imports); + model.default = getModelDefault(definition, model); + return model; + } + } + if ((_a = definition.oneOf) === null || _a === void 0 ? void 0 : _a.length) { + const composition = getModelComposition(openApi, definition, definition.oneOf, 'one-of', getModel); + model.export = composition.type; + model.imports.push(...composition.imports); + model.properties.push(...composition.properties); + model.enums.push(...composition.enums); + return model; + } + if ((_b = definition.anyOf) === null || _b === void 0 ? void 0 : _b.length) { + const composition = getModelComposition(openApi, definition, definition.anyOf, 'any-of', getModel); + model.export = composition.type; + model.imports.push(...composition.imports); + model.properties.push(...composition.properties); + model.enums.push(...composition.enums); + return model; + } + if ((_c = definition.allOf) === null || _c === void 0 ? void 0 : _c.length) { + const composition = getModelComposition(openApi, definition, definition.allOf, 'all-of', getModel); + model.export = composition.type; + model.imports.push(...composition.imports); + model.properties.push(...composition.properties); + model.enums.push(...composition.enums); + return model; + } + if (definition.type === 'object') { + if (definition.properties) { + model.export = 'interface'; + model.type = 'any'; + model.base = 'any'; + model.default = getModelDefault(definition, model); + const modelProperties = getModelProperties(openApi, definition, getModel, model); + modelProperties.forEach(modelProperty => { + model.imports.push(...modelProperty.imports); + model.enums.push(...modelProperty.enums); + model.properties.push(modelProperty); + if (modelProperty.export === 'enum') { + model.enums.push(modelProperty); + } + }); + return model; + } + else { + const additionalProperties = getModel(openApi, {}); + model.export = 'dictionary'; + model.type = additionalProperties.type; + model.base = additionalProperties.base; + model.template = additionalProperties.template; + model.link = additionalProperties; + model.imports.push(...additionalProperties.imports); + model.default = getModelDefault(definition, model); + return model; + } + } + // If the schema has a type than it can be a basic or generic type. + if (definition.type) { + const definitionType = getType(definition.type, definition.format); + model.export = 'generic'; + model.type = definitionType.type; + model.base = definitionType.base; + model.template = definitionType.template; + model.isNullable = definitionType.isNullable || model.isNullable; + model.imports.push(...definitionType.imports); + model.default = getModelDefault(definition, model); + return model; + } + return model; +}; + +const getModels = (openApi) => { + const models = []; + if (openApi.components) { + for (const definitionName in openApi.components.schemas) { + if (openApi.components.schemas.hasOwnProperty(definitionName)) { + const definition = openApi.components.schemas[definitionName]; + const definitionType = getType(definitionName); + const model = getModel(openApi, definition, true, definitionType.base.replace(reservedWords$1, '_$1')); + models.push(model); + } + } + } + return models; +}; + +const getServer = (openApi) => { + var _a; + const server = (_a = openApi.servers) === null || _a === void 0 ? void 0 : _a[0]; + const variables = (server === null || server === void 0 ? void 0 : server.variables) || {}; + let url = (server === null || server === void 0 ? void 0 : server.url) || ''; + for (const variable in variables) { + if (variables.hasOwnProperty(variable)) { + url = url.replace(`{${variable}}`, variables[variable].default); + } + } + return url.replace(/\/$/g, ''); +}; + +const getOperationErrors = (operationResponses) => { + return operationResponses + .filter(operationResponse => { + return operationResponse.code >= 300 && operationResponse.description; + }) + .map(response => ({ + code: response.code, + description: response.description, + })); +}; + +/** + * Convert the input value to a correct operation (method) classname. + * This will use the operation ID - if available - and otherwise fallback + * on a generated name from the URL + */ +const getOperationName = (url, method, operationId) => { + if (operationId) { + return camelCase(operationId + .replace(/^[^a-zA-Z]+/g, '') + .replace(/[^\w\-]+/g, '-') + .trim()); + } + const urlWithoutPlaceholders = url + .replace(/[^/]*?{api-version}.*?\//g, '') + .replace(/{(.*?)}/g, '') + .replace(/\//g, '-'); + return camelCase(`${method}-${urlWithoutPlaceholders}`); +}; + +const getOperationParameter = (openApi, parameter) => { + var _a; + const operationParameter = { + in: parameter.in, + prop: parameter.name, + export: 'interface', + name: getOperationParameterName$1(parameter.name), + type: 'any', + base: 'any', + template: null, + link: null, + description: parameter.description || null, + deprecated: parameter.deprecated === true, + isDefinition: false, + isReadOnly: false, + isRequired: parameter.required, + isNullable: parameter.nullable === true, + imports: [], + enum: [], + enums: [], + properties: [], + mediaType: null, + }; + if (parameter.$ref) { + const definitionRef = getType(parameter.$ref); + operationParameter.export = 'reference'; + operationParameter.type = definitionRef.type; + operationParameter.base = definitionRef.base; + operationParameter.template = definitionRef.template; + operationParameter.imports.push(...definitionRef.imports); + return operationParameter; + } + let schema = parameter.schema; + if (schema) { + if ((_a = schema.$ref) === null || _a === void 0 ? void 0 : _a.startsWith('#/components/parameters/')) { + schema = getRef(openApi, schema); + } + if (schema.$ref) { + const model = getType(schema.$ref); + operationParameter.export = 'reference'; + operationParameter.type = model.type; + operationParameter.base = model.base; + operationParameter.template = model.template; + operationParameter.imports.push(...model.imports); + operationParameter.default = getModelDefault(schema); + return operationParameter; + } + else { + const model = getModel(openApi, schema); + operationParameter.export = model.export; + operationParameter.type = model.type; + operationParameter.base = model.base; + operationParameter.template = model.template; + operationParameter.link = model.link; + operationParameter.isReadOnly = model.isReadOnly; + operationParameter.isRequired = operationParameter.isRequired || model.isRequired; + operationParameter.isNullable = operationParameter.isNullable || model.isNullable; + operationParameter.format = model.format; + operationParameter.maximum = model.maximum; + operationParameter.exclusiveMaximum = model.exclusiveMaximum; + operationParameter.minimum = model.minimum; + operationParameter.exclusiveMinimum = model.exclusiveMinimum; + operationParameter.multipleOf = model.multipleOf; + operationParameter.maxLength = model.maxLength; + operationParameter.minLength = model.minLength; + operationParameter.maxItems = model.maxItems; + operationParameter.minItems = model.minItems; + operationParameter.uniqueItems = model.uniqueItems; + operationParameter.maxProperties = model.maxProperties; + operationParameter.minProperties = model.minProperties; + operationParameter.pattern = getPattern(model.pattern); + operationParameter.default = model.default; + operationParameter.imports.push(...model.imports); + operationParameter.enum.push(...model.enum); + operationParameter.enums.push(...model.enums); + operationParameter.properties.push(...model.properties); + return operationParameter; + } + } + return operationParameter; +}; + +const getOperationParameters = (openApi, parameters) => { + const operationParameters = { + imports: [], + parameters: [], + parametersPath: [], + parametersQuery: [], + parametersForm: [], + parametersCookie: [], + parametersHeader: [], + parametersBody: null, // Not used in V3 -> @see requestBody + }; + // Iterate over the parameters + parameters.forEach(parameterOrReference => { + const parameterDef = getRef(openApi, parameterOrReference); + const parameter = getOperationParameter(openApi, parameterDef); + // We ignore the "api-version" param, since we do not want to add this + // as the first / default parameter for each of the service calls. + if (parameter.prop !== 'api-version') { + switch (parameterDef.in) { + case 'path': + operationParameters.parametersPath.push(parameter); + operationParameters.parameters.push(parameter); + operationParameters.imports.push(...parameter.imports); + break; + case 'query': + operationParameters.parametersQuery.push(parameter); + operationParameters.parameters.push(parameter); + operationParameters.imports.push(...parameter.imports); + break; + case 'formData': + operationParameters.parametersForm.push(parameter); + operationParameters.parameters.push(parameter); + operationParameters.imports.push(...parameter.imports); + break; + case 'cookie': + operationParameters.parametersCookie.push(parameter); + operationParameters.parameters.push(parameter); + operationParameters.imports.push(...parameter.imports); + break; + case 'header': + operationParameters.parametersHeader.push(parameter); + operationParameters.parameters.push(parameter); + operationParameters.imports.push(...parameter.imports); + break; + } + } + }); + return operationParameters; +}; + +const BASIC_MEDIA_TYPES = [ + 'application/json-patch+json', + 'application/json', + 'application/x-www-form-urlencoded', + 'text/json', + 'text/plain', + 'multipart/form-data', + 'multipart/mixed', + 'multipart/related', + 'multipart/batch', +]; +const getContent = (openApi, content) => { + const basicMediaTypeWithSchema = Object.keys(content) + .filter(mediaType => { + const cleanMediaType = mediaType.split(';')[0].trim(); + return BASIC_MEDIA_TYPES.includes(cleanMediaType); + }) + .find(mediaType => { var _a; return isDefined((_a = content[mediaType]) === null || _a === void 0 ? void 0 : _a.schema); }); + if (basicMediaTypeWithSchema) { + return { + mediaType: basicMediaTypeWithSchema, + schema: content[basicMediaTypeWithSchema].schema, + }; + } + const firstMediaTypeWithSchema = Object.keys(content).find(mediaType => { var _a; return isDefined((_a = content[mediaType]) === null || _a === void 0 ? void 0 : _a.schema); }); + if (firstMediaTypeWithSchema) { + return { + mediaType: firstMediaTypeWithSchema, + schema: content[firstMediaTypeWithSchema].schema, + }; + } + return null; +}; + +const getOperationRequestBody = (openApi, body) => { + const requestBody = { + in: 'body', + export: 'interface', + prop: 'requestBody', + name: 'requestBody', + type: 'any', + base: 'any', + template: null, + link: null, + description: body.description || null, + default: undefined, + isDefinition: false, + isReadOnly: false, + isRequired: body.required === true, + isNullable: body.nullable === true, + imports: [], + enum: [], + enums: [], + properties: [], + mediaType: null, + }; + if (body.content) { + const content = getContent(openApi, body.content); + if (content) { + requestBody.mediaType = content.mediaType; + switch (requestBody.mediaType) { + case 'application/x-www-form-urlencoded': + case 'multipart/form-data': + requestBody.in = 'formData'; + requestBody.name = 'formData'; + requestBody.prop = 'formData'; + break; + } + if (content.schema.$ref) { + const model = getType(content.schema.$ref); + requestBody.export = 'reference'; + requestBody.type = model.type; + requestBody.base = model.base; + requestBody.template = model.template; + requestBody.imports.push(...model.imports); + return requestBody; + } + else { + const model = getModel(openApi, content.schema); + requestBody.export = model.export; + requestBody.type = model.type; + requestBody.base = model.base; + requestBody.template = model.template; + requestBody.link = model.link; + requestBody.isReadOnly = model.isReadOnly; + requestBody.isRequired = requestBody.isRequired || model.isRequired; + requestBody.isNullable = requestBody.isNullable || model.isNullable; + requestBody.format = model.format; + requestBody.maximum = model.maximum; + requestBody.exclusiveMaximum = model.exclusiveMaximum; + requestBody.minimum = model.minimum; + requestBody.exclusiveMinimum = model.exclusiveMinimum; + requestBody.multipleOf = model.multipleOf; + requestBody.maxLength = model.maxLength; + requestBody.minLength = model.minLength; + requestBody.maxItems = model.maxItems; + requestBody.minItems = model.minItems; + requestBody.uniqueItems = model.uniqueItems; + requestBody.maxProperties = model.maxProperties; + requestBody.minProperties = model.minProperties; + requestBody.pattern = getPattern(model.pattern); + requestBody.imports.push(...model.imports); + requestBody.enum.push(...model.enum); + requestBody.enums.push(...model.enums); + requestBody.properties.push(...model.properties); + return requestBody; + } + } + } + return requestBody; +}; + +const getOperationResponseHeader = (operationResponses) => { + const header = operationResponses.find(operationResponses => { + return operationResponses.in === 'header'; + }); + if (header) { + return header.name; + } + return null; +}; + +const getOperationResponse = (openApi, response, responseCode) => { + var _a; + const operationResponse = { + in: 'response', + name: '', + code: responseCode, + description: response.description || null, + export: 'generic', + type: 'any', + base: 'any', + template: null, + link: null, + isDefinition: false, + isReadOnly: false, + isRequired: false, + isNullable: false, + imports: [], + enum: [], + enums: [], + properties: [], + }; + if (response.content) { + const content = getContent(openApi, response.content); + if (content) { + if ((_a = content.schema.$ref) === null || _a === void 0 ? void 0 : _a.startsWith('#/components/responses/')) { + content.schema = getRef(openApi, content.schema); + } + if (content.schema.$ref) { + const model = getType(content.schema.$ref); + operationResponse.export = 'reference'; + operationResponse.type = model.type; + operationResponse.base = model.base; + operationResponse.template = model.template; + operationResponse.imports.push(...model.imports); + return operationResponse; + } + else { + const model = getModel(openApi, content.schema); + operationResponse.export = model.export; + operationResponse.type = model.type; + operationResponse.base = model.base; + operationResponse.template = model.template; + operationResponse.link = model.link; + operationResponse.isReadOnly = model.isReadOnly; + operationResponse.isRequired = model.isRequired; + operationResponse.isNullable = model.isNullable; + operationResponse.format = model.format; + operationResponse.maximum = model.maximum; + operationResponse.exclusiveMaximum = model.exclusiveMaximum; + operationResponse.minimum = model.minimum; + operationResponse.exclusiveMinimum = model.exclusiveMinimum; + operationResponse.multipleOf = model.multipleOf; + operationResponse.maxLength = model.maxLength; + operationResponse.minLength = model.minLength; + operationResponse.maxItems = model.maxItems; + operationResponse.minItems = model.minItems; + operationResponse.uniqueItems = model.uniqueItems; + operationResponse.maxProperties = model.maxProperties; + operationResponse.minProperties = model.minProperties; + operationResponse.pattern = getPattern(model.pattern); + operationResponse.imports.push(...model.imports); + operationResponse.enum.push(...model.enum); + operationResponse.enums.push(...model.enums); + operationResponse.properties.push(...model.properties); + return operationResponse; + } + } + } + // We support basic properties from response headers, since both + // fetch and XHR client just support string types. + if (response.headers) { + for (const name in response.headers) { + if (response.headers.hasOwnProperty(name)) { + operationResponse.in = 'header'; + operationResponse.name = name; + operationResponse.type = 'string'; + operationResponse.base = 'string'; + return operationResponse; + } + } + } + return operationResponse; +}; + +const getOperationResponseCode = (value) => { + // You can specify a "default" response, this is treated as HTTP code 200 + if (value === 'default') { + return 200; + } + // Check if we can parse the code and return of successful. + if (/[0-9]+/g.test(value)) { + const code = parseInt(value); + if (Number.isInteger(code)) { + return Math.abs(code); + } + } + return null; +}; + +const getOperationResponses = (openApi, responses) => { + const operationResponses = []; + // Iterate over each response code and get the + // status code and response message (if any). + for (const code in responses) { + if (responses.hasOwnProperty(code)) { + const responseOrReference = responses[code]; + const response = getRef(openApi, responseOrReference); + const responseCode = getOperationResponseCode(code); + if (responseCode) { + const operationResponse = getOperationResponse(openApi, response, responseCode); + operationResponses.push(operationResponse); + } + } + } + // Sort the responses to 2XX success codes come before 4XX and 5XX error codes. + return operationResponses.sort((a, b) => { + return a.code < b.code ? -1 : a.code > b.code ? 1 : 0; + }); +}; + +const areEqual = (a, b) => { + const equal = a.type === b.type && a.base === b.base && a.template === b.template; + if (equal && a.link && b.link) { + return areEqual(a.link, b.link); + } + return equal; +}; +const getOperationResults = (operationResponses) => { + const operationResults = []; + // Filter out success response codes, but skip "204 No Content" + operationResponses.forEach(operationResponse => { + const { code } = operationResponse; + if (code && code !== 204 && code >= 200 && code < 300) { + operationResults.push(operationResponse); + } + }); + if (!operationResults.length) { + operationResults.push({ + in: 'response', + name: '', + code: 200, + description: '', + export: 'generic', + type: 'void', + base: 'void', + template: null, + link: null, + isDefinition: false, + isReadOnly: false, + isRequired: false, + isNullable: false, + imports: [], + enum: [], + enums: [], + properties: [], + }); + } + return operationResults.filter((operationResult, index, arr) => { + return (arr.findIndex(item => { + return areEqual(item, operationResult); + }) === index); + }); +}; + +/** + * Convert the input value to a correct service name. This converts + * the input string to PascalCase. + */ +const getServiceName = (value) => { + const clean = value + .replace(/^[^a-zA-Z]+/g, '') + .replace(/[^\w\-]+/g, '-') + .trim(); + return camelCase(clean, { pascalCase: true }); +}; + +const sortByRequired = (a, b) => { + const aNeedsValue = a.isRequired && a.default === undefined; + const bNeedsValue = b.isRequired && b.default === undefined; + if (aNeedsValue && !bNeedsValue) + return -1; + if (bNeedsValue && !aNeedsValue) + return 1; + return 0; +}; + +const getOperation = (openApi, url, method, tag, op, pathParams) => { + const serviceName = getServiceName(tag); + const operationName = getOperationName(url, method, op.operationId); + // Create a new operation object for this method. + const operation = { + service: serviceName, + name: operationName, + summary: op.summary || null, + description: op.description || null, + deprecated: op.deprecated === true, + method: method.toUpperCase(), + path: url, + parameters: [...pathParams.parameters], + parametersPath: [...pathParams.parametersPath], + parametersQuery: [...pathParams.parametersQuery], + parametersForm: [...pathParams.parametersForm], + parametersHeader: [...pathParams.parametersHeader], + parametersCookie: [...pathParams.parametersCookie], + parametersBody: pathParams.parametersBody, + imports: [], + errors: [], + results: [], + responseHeader: null, + }; + // Parse the operation parameters (path, query, body, etc). + if (op.parameters) { + const parameters = getOperationParameters(openApi, op.parameters); + operation.imports.push(...parameters.imports); + operation.parameters.push(...parameters.parameters); + operation.parametersPath.push(...parameters.parametersPath); + operation.parametersQuery.push(...parameters.parametersQuery); + operation.parametersForm.push(...parameters.parametersForm); + operation.parametersHeader.push(...parameters.parametersHeader); + operation.parametersCookie.push(...parameters.parametersCookie); + operation.parametersBody = parameters.parametersBody; + } + if (op.requestBody) { + const requestBodyDef = getRef(openApi, op.requestBody); + const requestBody = getOperationRequestBody(openApi, requestBodyDef); + operation.imports.push(...requestBody.imports); + operation.parameters.push(requestBody); + operation.parametersBody = requestBody; + } + // Parse the operation responses. + if (op.responses) { + const operationResponses = getOperationResponses(openApi, op.responses); + const operationResults = getOperationResults(operationResponses); + operation.errors = getOperationErrors(operationResponses); + operation.responseHeader = getOperationResponseHeader(operationResults); + operationResults.forEach(operationResult => { + operation.results.push(operationResult); + operation.imports.push(...operationResult.imports); + }); + } + operation.parameters = operation.parameters.sort(sortByRequired); + return operation; +}; + +/** + * Get the OpenAPI services + */ +const getServices = (openApi) => { + var _a; + const services = new Map(); + for (const url in openApi.paths) { + if (openApi.paths.hasOwnProperty(url)) { + // Grab path and parse any global path parameters + const path = openApi.paths[url]; + const pathParams = getOperationParameters(openApi, path.parameters || []); + // Parse all the methods for this path + for (const method in path) { + if (path.hasOwnProperty(method)) { + switch (method) { + case 'get': + case 'put': + case 'post': + case 'delete': + case 'options': + case 'head': + case 'patch': + // Each method contains an OpenAPI operation, we parse the operation + const op = path[method]; + const tags = ((_a = op.tags) === null || _a === void 0 ? void 0 : _a.length) ? op.tags.filter(unique) : ['Default']; + tags.forEach(tag => { + const operation = getOperation(openApi, url, method, tag, op, pathParams); + // If we have already declared a service, then we should fetch that and + // append the new method to it. Otherwise we should create a new service object. + const service = services.get(operation.service) || { + name: operation.service, + operations: [], + imports: [], + }; + // Push the operation in the service + service.operations.push(operation); + service.imports.push(...operation.imports); + services.set(operation.service, service); + }); + break; + } + } + } + } + } + return Array.from(services.values()); +}; + +/** + * Convert the service version to 'normal' version. + * This basically removes any "v" prefix from the version string. + * @param version + */ +const getServiceVersion = (version = '1.0') => { + return String(version).replace(/^v/gi, ''); +}; + +/** + * Parse the OpenAPI specification to a Client model that contains + * all the models, services and schema's we should output. + * @param openApi The OpenAPI spec that we have loaded from disk. + */ +const parse = (openApi) => { + const version = getServiceVersion(openApi.info.version); + const server = getServer(openApi); + const models = getModels(openApi); + const services = getServices(openApi); + return { version, server, models, services }; +}; + +/** + * Load and parse te open api spec. If the file extension is ".yml" or ".yaml" + * we will try to parse the file as a YAML spec, otherwise we will fall back + * on parsing the file as JSON. + * @param location: Path or url + */ +const getOpenApiSpec = async (location) => { + return await RefParser.bundle(location, location, {}); +}; + +var OpenApiVersion; +(function (OpenApiVersion) { + OpenApiVersion[OpenApiVersion["V2"] = 2] = "V2"; + OpenApiVersion[OpenApiVersion["V3"] = 3] = "V3"; +})(OpenApiVersion || (OpenApiVersion = {})); +/** + * Get the Open API specification version (V2 or V3). This generator only supports + * version 2 and 3 of the specification, so we will alert the user if we encounter + * an incompatible type. Or if the type is missing... + * @param openApi The loaded spec (can be any object) + */ +const getOpenApiVersion = (openApi) => { + const info = openApi.swagger || openApi.openapi; + if (typeof info === 'string') { + const c = info.charAt(0); + const v = Number.parseInt(c); + if (v === OpenApiVersion.V2 || v === OpenApiVersion.V3) { + return v; + } + } + throw new Error(`Unsupported Open API version: "${String(info)}"`); +}; + +/** + * Set unique enum values for the model + * @param model + */ +const postProcessModelEnum = (model) => { + return model.enum.filter((property, index, arr) => { + return arr.findIndex(item => item.name === property.name) === index; + }); +}; + +/** + * Set unique enum values for the model + * @param model The model that is post-processed + */ +const postProcessModelEnums = (model) => { + return model.enums.filter((property, index, arr) => { + return arr.findIndex(item => item.name === property.name) === index; + }); +}; + +const sort = (a, b) => { + const nameA = a.toLowerCase(); + const nameB = b.toLowerCase(); + return nameA.localeCompare(nameB, 'en'); +}; + +/** + * Set unique imports, sorted by name + * @param model The model that is post-processed + */ +const postProcessModelImports = (model) => { + return model.imports + .filter(unique) + .sort(sort) + .filter(name => model.name !== name); +}; + +/** + * Post processes the model. + * This will clean up any double imports or enum values. + * @param model + */ +const postProcessModel = (model) => { + return { + ...model, + imports: postProcessModelImports(model), + enums: postProcessModelEnums(model), + enum: postProcessModelEnum(model), + }; +}; + +/** + * Set unique imports, sorted by name + * @param service + */ +const postProcessServiceImports = (service) => { + return service.imports.filter(unique).sort(sort); +}; + +/** + * Calls a defined callback on each element of an array. + * Then, flattens the result into a new array. + */ +const flatMap = (array, callback) => { + const result = []; + array.map(callback).forEach(arr => { + result.push(...arr); + }); + return result; +}; + +const postProcessServiceOperations = (service) => { + const names = new Map(); + return service.operations.map(operation => { + const clone = { ...operation }; + // Parse the service parameters and results, very similar to how we parse + // properties of models. These methods will extend the type if needed. + clone.imports.push(...flatMap(clone.parameters, parameter => parameter.imports)); + clone.imports.push(...flatMap(clone.results, result => result.imports)); + // Check if the operation name is unique, if not then prefix this with a number + const name = clone.name; + const index = names.get(name) || 0; + if (index > 0) { + clone.name = `${name}${index}`; + } + names.set(name, index + 1); + return clone; + }); +}; + +const postProcessService = (service) => { + const clone = { ...service }; + clone.operations = postProcessServiceOperations(clone); + clone.operations.forEach(operation => { + clone.imports.push(...operation.imports); + }); + clone.imports = postProcessServiceImports(clone); + return clone; +}; + +/** + * Post process client + * @param client Client object with all the models, services, etc. + */ +const postProcessClient = (client) => { + return { + ...client, + models: client.models.map(model => postProcessModel(model)), + services: client.services.map(service => postProcessService(service)), + }; +}; + +var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + +var handlebars_runtime = {exports: {}}; + +var base = {}; + +var utils = {}; + +utils.__esModule = true; +utils.extend = extend; +utils.indexOf = indexOf; +utils.escapeExpression = escapeExpression; +utils.isEmpty = isEmpty; +utils.createFrame = createFrame; +utils.blockParams = blockParams; +utils.appendContextPath = appendContextPath; +var escape = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', + '`': '`', + '=': '=' +}; + +var badChars = /[&<>"'`=]/g, + possible = /[&<>"'`=]/; + +function escapeChar(chr) { + return escape[chr]; +} + +function extend(obj /* , ...source */) { + for (var i = 1; i < arguments.length; i++) { + for (var key in arguments[i]) { + if (Object.prototype.hasOwnProperty.call(arguments[i], key)) { + obj[key] = arguments[i][key]; + } + } + } + + return obj; +} + +var toString = Object.prototype.toString; + +utils.toString = toString; +// Sourced from lodash +// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt +/* eslint-disable func-style */ +var isFunction = function isFunction(value) { + return typeof value === 'function'; +}; +// fallback for older versions of Chrome and Safari +/* istanbul ignore next */ +if (isFunction(/x/)) { + utils.isFunction = isFunction = function (value) { + return typeof value === 'function' && toString.call(value) === '[object Function]'; + }; +} +utils.isFunction = isFunction; + +/* eslint-enable func-style */ + +/* istanbul ignore next */ +var isArray = Array.isArray || function (value) { + return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false; +}; + +utils.isArray = isArray; +// Older IE versions do not directly support indexOf so we must implement our own, sadly. + +function indexOf(array, value) { + for (var i = 0, len = array.length; i < len; i++) { + if (array[i] === value) { + return i; + } + } + return -1; +} + +function escapeExpression(string) { + if (typeof string !== 'string') { + // don't escape SafeStrings, since they're already safe + if (string && string.toHTML) { + return string.toHTML(); + } else if (string == null) { + return ''; + } else if (!string) { + return string + ''; + } + + // Force a string conversion as this will be done by the append regardless and + // the regex test will do this transparently behind the scenes, causing issues if + // an object's to string has escaped characters in it. + string = '' + string; + } + + if (!possible.test(string)) { + return string; + } + return string.replace(badChars, escapeChar); +} + +function isEmpty(value) { + if (!value && value !== 0) { + return true; + } else if (isArray(value) && value.length === 0) { + return true; + } else { + return false; + } +} + +function createFrame(object) { + var frame = extend({}, object); + frame._parent = object; + return frame; +} + +function blockParams(params, ids) { + params.path = ids; + return params; +} + +function appendContextPath(contextPath, id) { + return (contextPath ? contextPath + '.' : '') + id; +} + +var exception = {exports: {}}; + +(function (module, exports) { + + exports.__esModule = true; + var errorProps = ['description', 'fileName', 'lineNumber', 'endLineNumber', 'message', 'name', 'number', 'stack']; + + function Exception(message, node) { + var loc = node && node.loc, + line = undefined, + endLineNumber = undefined, + column = undefined, + endColumn = undefined; + + if (loc) { + line = loc.start.line; + endLineNumber = loc.end.line; + column = loc.start.column; + endColumn = loc.end.column; + + message += ' - ' + line + ':' + column; + } + + var tmp = Error.prototype.constructor.call(this, message); + + // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work. + for (var idx = 0; idx < errorProps.length; idx++) { + this[errorProps[idx]] = tmp[errorProps[idx]]; + } + + /* istanbul ignore else */ + if (Error.captureStackTrace) { + Error.captureStackTrace(this, Exception); + } + + try { + if (loc) { + this.lineNumber = line; + this.endLineNumber = endLineNumber; + + // Work around issue under safari where we can't directly set the column value + /* istanbul ignore next */ + if (Object.defineProperty) { + Object.defineProperty(this, 'column', { + value: column, + enumerable: true + }); + Object.defineProperty(this, 'endColumn', { + value: endColumn, + enumerable: true + }); + } else { + this.column = column; + this.endColumn = endColumn; + } + } + } catch (nop) { + /* Ignore if the browser is very particular */ + } + } + + Exception.prototype = new Error(); + + exports['default'] = Exception; + module.exports = exports['default']; + +} (exception, exception.exports)); + +var helpers = {}; + +var blockHelperMissing = {exports: {}}; + +(function (module, exports) { + + exports.__esModule = true; + + var _utils = utils; + + exports['default'] = function (instance) { + instance.registerHelper('blockHelperMissing', function (context, options) { + var inverse = options.inverse, + fn = options.fn; + + if (context === true) { + return fn(this); + } else if (context === false || context == null) { + return inverse(this); + } else if (_utils.isArray(context)) { + if (context.length > 0) { + if (options.ids) { + options.ids = [options.name]; + } + + return instance.helpers.each(context, options); + } else { + return inverse(this); + } + } else { + if (options.data && options.ids) { + var data = _utils.createFrame(options.data); + data.contextPath = _utils.appendContextPath(options.data.contextPath, options.name); + options = { data: data }; + } + + return fn(context, options); + } + }); + }; + + module.exports = exports['default']; + +} (blockHelperMissing, blockHelperMissing.exports)); + +var each = {exports: {}}; + +(function (module, exports) { + + exports.__esModule = true; + // istanbul ignore next + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _utils = utils; + + var _exception = exception.exports; + + var _exception2 = _interopRequireDefault(_exception); + + exports['default'] = function (instance) { + instance.registerHelper('each', function (context, options) { + if (!options) { + throw new _exception2['default']('Must pass iterator to #each'); + } + + var fn = options.fn, + inverse = options.inverse, + i = 0, + ret = '', + data = undefined, + contextPath = undefined; + + if (options.data && options.ids) { + contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.'; + } + + if (_utils.isFunction(context)) { + context = context.call(this); + } + + if (options.data) { + data = _utils.createFrame(options.data); + } + + function execIteration(field, index, last) { + if (data) { + data.key = field; + data.index = index; + data.first = index === 0; + data.last = !!last; + + if (contextPath) { + data.contextPath = contextPath + field; + } + } + + ret = ret + fn(context[field], { + data: data, + blockParams: _utils.blockParams([context[field], field], [contextPath + field, null]) + }); + } + + if (context && typeof context === 'object') { + if (_utils.isArray(context)) { + for (var j = context.length; i < j; i++) { + if (i in context) { + execIteration(i, i, i === context.length - 1); + } + } + } else if (commonjsGlobal.Symbol && context[commonjsGlobal.Symbol.iterator]) { + var newContext = []; + var iterator = context[commonjsGlobal.Symbol.iterator](); + for (var it = iterator.next(); !it.done; it = iterator.next()) { + newContext.push(it.value); + } + context = newContext; + for (var j = context.length; i < j; i++) { + execIteration(i, i, i === context.length - 1); + } + } else { + (function () { + var priorKey = undefined; + + Object.keys(context).forEach(function (key) { + // We're running the iterations one step out of sync so we can detect + // the last iteration without have to scan the object twice and create + // an itermediate keys array. + if (priorKey !== undefined) { + execIteration(priorKey, i - 1); + } + priorKey = key; + i++; + }); + if (priorKey !== undefined) { + execIteration(priorKey, i - 1, true); + } + })(); + } + } + + if (i === 0) { + ret = inverse(this); + } + + return ret; + }); + }; + + module.exports = exports['default']; + +} (each, each.exports)); + +var helperMissing = {exports: {}}; + +(function (module, exports) { + + exports.__esModule = true; + // istanbul ignore next + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _exception = exception.exports; + + var _exception2 = _interopRequireDefault(_exception); + + exports['default'] = function (instance) { + instance.registerHelper('helperMissing', function () /* [args, ]options */{ + if (arguments.length === 1) { + // A missing field in a {{foo}} construct. + return undefined; + } else { + // Someone is actually trying to call something, blow up. + throw new _exception2['default']('Missing helper: "' + arguments[arguments.length - 1].name + '"'); + } + }); + }; + + module.exports = exports['default']; + +} (helperMissing, helperMissing.exports)); + +var _if = {exports: {}}; + +(function (module, exports) { + + exports.__esModule = true; + // istanbul ignore next + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _utils = utils; + + var _exception = exception.exports; + + var _exception2 = _interopRequireDefault(_exception); + + exports['default'] = function (instance) { + instance.registerHelper('if', function (conditional, options) { + if (arguments.length != 2) { + throw new _exception2['default']('#if requires exactly one argument'); + } + if (_utils.isFunction(conditional)) { + conditional = conditional.call(this); + } + + // Default behavior is to render the positive path if the value is truthy and not empty. + // The `includeZero` option may be set to treat the condtional as purely not empty based on the + // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative. + if (!options.hash.includeZero && !conditional || _utils.isEmpty(conditional)) { + return options.inverse(this); + } else { + return options.fn(this); + } + }); + + instance.registerHelper('unless', function (conditional, options) { + if (arguments.length != 2) { + throw new _exception2['default']('#unless requires exactly one argument'); + } + return instance.helpers['if'].call(this, conditional, { + fn: options.inverse, + inverse: options.fn, + hash: options.hash + }); + }); + }; + + module.exports = exports['default']; + +} (_if, _if.exports)); + +var log$1 = {exports: {}}; + +(function (module, exports) { + + exports.__esModule = true; + + exports['default'] = function (instance) { + instance.registerHelper('log', function () /* message, options */{ + var args = [undefined], + options = arguments[arguments.length - 1]; + for (var i = 0; i < arguments.length - 1; i++) { + args.push(arguments[i]); + } + + var level = 1; + if (options.hash.level != null) { + level = options.hash.level; + } else if (options.data && options.data.level != null) { + level = options.data.level; + } + args[0] = level; + + instance.log.apply(instance, args); + }); + }; + + module.exports = exports['default']; + +} (log$1, log$1.exports)); + +var lookup = {exports: {}}; + +(function (module, exports) { + + exports.__esModule = true; + + exports['default'] = function (instance) { + instance.registerHelper('lookup', function (obj, field, options) { + if (!obj) { + // Note for 5.0: Change to "obj == null" in 5.0 + return obj; + } + return options.lookupProperty(obj, field); + }); + }; + + module.exports = exports['default']; + +} (lookup, lookup.exports)); + +var _with = {exports: {}}; + +(function (module, exports) { + + exports.__esModule = true; + // istanbul ignore next + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _utils = utils; + + var _exception = exception.exports; + + var _exception2 = _interopRequireDefault(_exception); + + exports['default'] = function (instance) { + instance.registerHelper('with', function (context, options) { + if (arguments.length != 2) { + throw new _exception2['default']('#with requires exactly one argument'); + } + if (_utils.isFunction(context)) { + context = context.call(this); + } + + var fn = options.fn; + + if (!_utils.isEmpty(context)) { + var data = options.data; + if (options.data && options.ids) { + data = _utils.createFrame(options.data); + data.contextPath = _utils.appendContextPath(options.data.contextPath, options.ids[0]); + } + + return fn(context, { + data: data, + blockParams: _utils.blockParams([context], [data && data.contextPath]) + }); + } else { + return options.inverse(this); + } + }); + }; + + module.exports = exports['default']; + +} (_with, _with.exports)); + +helpers.__esModule = true; +helpers.registerDefaultHelpers = registerDefaultHelpers; +helpers.moveHelperToHooks = moveHelperToHooks; +// istanbul ignore next + +function _interopRequireDefault$3(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + +var _helpersBlockHelperMissing = blockHelperMissing.exports; + +var _helpersBlockHelperMissing2 = _interopRequireDefault$3(_helpersBlockHelperMissing); + +var _helpersEach = each.exports; + +var _helpersEach2 = _interopRequireDefault$3(_helpersEach); + +var _helpersHelperMissing = helperMissing.exports; + +var _helpersHelperMissing2 = _interopRequireDefault$3(_helpersHelperMissing); + +var _helpersIf = _if.exports; + +var _helpersIf2 = _interopRequireDefault$3(_helpersIf); + +var _helpersLog = log$1.exports; + +var _helpersLog2 = _interopRequireDefault$3(_helpersLog); + +var _helpersLookup = lookup.exports; + +var _helpersLookup2 = _interopRequireDefault$3(_helpersLookup); + +var _helpersWith = _with.exports; + +var _helpersWith2 = _interopRequireDefault$3(_helpersWith); + +function registerDefaultHelpers(instance) { + _helpersBlockHelperMissing2['default'](instance); + _helpersEach2['default'](instance); + _helpersHelperMissing2['default'](instance); + _helpersIf2['default'](instance); + _helpersLog2['default'](instance); + _helpersLookup2['default'](instance); + _helpersWith2['default'](instance); +} + +function moveHelperToHooks(instance, helperName, keepHelper) { + if (instance.helpers[helperName]) { + instance.hooks[helperName] = instance.helpers[helperName]; + if (!keepHelper) { + delete instance.helpers[helperName]; + } + } +} + +var decorators = {}; + +var inline = {exports: {}}; + +(function (module, exports) { + + exports.__esModule = true; + + var _utils = utils; + + exports['default'] = function (instance) { + instance.registerDecorator('inline', function (fn, props, container, options) { + var ret = fn; + if (!props.partials) { + props.partials = {}; + ret = function (context, options) { + // Create a new partials stack frame prior to exec. + var original = container.partials; + container.partials = _utils.extend({}, original, props.partials); + var ret = fn(context, options); + container.partials = original; + return ret; + }; + } + + props.partials[options.args[0]] = options.fn; + + return ret; + }); + }; + + module.exports = exports['default']; + +} (inline, inline.exports)); + +decorators.__esModule = true; +decorators.registerDefaultDecorators = registerDefaultDecorators; +// istanbul ignore next + +function _interopRequireDefault$2(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + +var _decoratorsInline = inline.exports; + +var _decoratorsInline2 = _interopRequireDefault$2(_decoratorsInline); + +function registerDefaultDecorators(instance) { + _decoratorsInline2['default'](instance); +} + +var logger$1 = {exports: {}}; + +(function (module, exports) { + + exports.__esModule = true; + + var _utils = utils; + + var logger = { + methodMap: ['debug', 'info', 'warn', 'error'], + level: 'info', + + // Maps a given level value to the `methodMap` indexes above. + lookupLevel: function lookupLevel(level) { + if (typeof level === 'string') { + var levelMap = _utils.indexOf(logger.methodMap, level.toLowerCase()); + if (levelMap >= 0) { + level = levelMap; + } else { + level = parseInt(level, 10); + } + } + + return level; + }, + + // Can be overridden in the host environment + log: function log(level) { + level = logger.lookupLevel(level); + + if (typeof console !== 'undefined' && logger.lookupLevel(logger.level) <= level) { + var method = logger.methodMap[level]; + // eslint-disable-next-line no-console + if (!console[method]) { + method = 'log'; + } + + for (var _len = arguments.length, message = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + message[_key - 1] = arguments[_key]; + } + + console[method].apply(console, message); // eslint-disable-line no-console + } + } + }; + + exports['default'] = logger; + module.exports = exports['default']; + +} (logger$1, logger$1.exports)); + +var protoAccess = {}; + +var createNewLookupObject$1 = {}; + +createNewLookupObject$1.__esModule = true; +createNewLookupObject$1.createNewLookupObject = createNewLookupObject; + +var _utils$2 = utils; + +/** + * Create a new object with "null"-prototype to avoid truthy results on prototype properties. + * The resulting object can be used with "object[property]" to check if a property exists + * @param {...object} sources a varargs parameter of source objects that will be merged + * @returns {object} + */ + +function createNewLookupObject() { + for (var _len = arguments.length, sources = Array(_len), _key = 0; _key < _len; _key++) { + sources[_key] = arguments[_key]; + } + + return _utils$2.extend.apply(undefined, [Object.create(null)].concat(sources)); +} + +protoAccess.__esModule = true; +protoAccess.createProtoAccessControl = createProtoAccessControl; +protoAccess.resultIsAllowed = resultIsAllowed; +protoAccess.resetLoggedProperties = resetLoggedProperties; +// istanbul ignore next + +function _interopRequireWildcard$1(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } } + +var _createNewLookupObject = createNewLookupObject$1; + +var _logger$1 = logger$1.exports; + +var logger = _interopRequireWildcard$1(_logger$1); + +var loggedProperties = Object.create(null); + +function createProtoAccessControl(runtimeOptions) { + var defaultMethodWhiteList = Object.create(null); + defaultMethodWhiteList['constructor'] = false; + defaultMethodWhiteList['__defineGetter__'] = false; + defaultMethodWhiteList['__defineSetter__'] = false; + defaultMethodWhiteList['__lookupGetter__'] = false; + + var defaultPropertyWhiteList = Object.create(null); + // eslint-disable-next-line no-proto + defaultPropertyWhiteList['__proto__'] = false; + + return { + properties: { + whitelist: _createNewLookupObject.createNewLookupObject(defaultPropertyWhiteList, runtimeOptions.allowedProtoProperties), + defaultValue: runtimeOptions.allowProtoPropertiesByDefault + }, + methods: { + whitelist: _createNewLookupObject.createNewLookupObject(defaultMethodWhiteList, runtimeOptions.allowedProtoMethods), + defaultValue: runtimeOptions.allowProtoMethodsByDefault + } + }; +} + +function resultIsAllowed(result, protoAccessControl, propertyName) { + if (typeof result === 'function') { + return checkWhiteList(protoAccessControl.methods, propertyName); + } else { + return checkWhiteList(protoAccessControl.properties, propertyName); + } +} + +function checkWhiteList(protoAccessControlForType, propertyName) { + if (protoAccessControlForType.whitelist[propertyName] !== undefined) { + return protoAccessControlForType.whitelist[propertyName] === true; + } + if (protoAccessControlForType.defaultValue !== undefined) { + return protoAccessControlForType.defaultValue; + } + logUnexpecedPropertyAccessOnce(propertyName); + return false; +} + +function logUnexpecedPropertyAccessOnce(propertyName) { + if (loggedProperties[propertyName] !== true) { + loggedProperties[propertyName] = true; + logger.log('error', 'Handlebars: Access has been denied to resolve the property "' + propertyName + '" because it is not an "own property" of its parent.\n' + 'You can add a runtime option to disable the check or this warning:\n' + 'See https://handlebarsjs.com/api-reference/runtime-options.html#options-to-control-prototype-access for details'); + } +} + +function resetLoggedProperties() { + Object.keys(loggedProperties).forEach(function (propertyName) { + delete loggedProperties[propertyName]; + }); +} + +base.__esModule = true; +base.HandlebarsEnvironment = HandlebarsEnvironment; +// istanbul ignore next + +function _interopRequireDefault$1(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + +var _utils$1 = utils; + +var _exception$1 = exception.exports; + +var _exception2$1 = _interopRequireDefault$1(_exception$1); + +var _helpers$1 = helpers; + +var _decorators = decorators; + +var _logger = logger$1.exports; + +var _logger2 = _interopRequireDefault$1(_logger); + +var _internalProtoAccess$1 = protoAccess; + +var VERSION = '4.7.7'; +base.VERSION = VERSION; +var COMPILER_REVISION = 8; +base.COMPILER_REVISION = COMPILER_REVISION; +var LAST_COMPATIBLE_COMPILER_REVISION = 7; + +base.LAST_COMPATIBLE_COMPILER_REVISION = LAST_COMPATIBLE_COMPILER_REVISION; +var REVISION_CHANGES = { + 1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it + 2: '== 1.0.0-rc.3', + 3: '== 1.0.0-rc.4', + 4: '== 1.x.x', + 5: '== 2.0.0-alpha.x', + 6: '>= 2.0.0-beta.1', + 7: '>= 4.0.0 <4.3.0', + 8: '>= 4.3.0' +}; + +base.REVISION_CHANGES = REVISION_CHANGES; +var objectType = '[object Object]'; + +function HandlebarsEnvironment(helpers, partials, decorators) { + this.helpers = helpers || {}; + this.partials = partials || {}; + this.decorators = decorators || {}; + + _helpers$1.registerDefaultHelpers(this); + _decorators.registerDefaultDecorators(this); +} + +HandlebarsEnvironment.prototype = { + constructor: HandlebarsEnvironment, + + logger: _logger2['default'], + log: _logger2['default'].log, + + registerHelper: function registerHelper(name, fn) { + if (_utils$1.toString.call(name) === objectType) { + if (fn) { + throw new _exception2$1['default']('Arg not supported with multiple helpers'); + } + _utils$1.extend(this.helpers, name); + } else { + this.helpers[name] = fn; + } + }, + unregisterHelper: function unregisterHelper(name) { + delete this.helpers[name]; + }, + + registerPartial: function registerPartial(name, partial) { + if (_utils$1.toString.call(name) === objectType) { + _utils$1.extend(this.partials, name); + } else { + if (typeof partial === 'undefined') { + throw new _exception2$1['default']('Attempting to register a partial called "' + name + '" as undefined'); + } + this.partials[name] = partial; + } + }, + unregisterPartial: function unregisterPartial(name) { + delete this.partials[name]; + }, + + registerDecorator: function registerDecorator(name, fn) { + if (_utils$1.toString.call(name) === objectType) { + if (fn) { + throw new _exception2$1['default']('Arg not supported with multiple decorators'); + } + _utils$1.extend(this.decorators, name); + } else { + this.decorators[name] = fn; + } + }, + unregisterDecorator: function unregisterDecorator(name) { + delete this.decorators[name]; + }, + /** + * Reset the memory of illegal property accesses that have already been logged. + * @deprecated should only be used in handlebars test-cases + */ + resetLoggedPropertyAccesses: function resetLoggedPropertyAccesses() { + _internalProtoAccess$1.resetLoggedProperties(); + } +}; + +var log = _logger2['default'].log; + +base.log = log; +base.createFrame = _utils$1.createFrame; +base.logger = _logger2['default']; + +var safeString = {exports: {}}; + +(function (module, exports) { + + exports.__esModule = true; + function SafeString(string) { + this.string = string; + } + + SafeString.prototype.toString = SafeString.prototype.toHTML = function () { + return '' + this.string; + }; + + exports['default'] = SafeString; + module.exports = exports['default']; + +} (safeString, safeString.exports)); + +var runtime$1 = {}; + +var wrapHelper$1 = {}; + +wrapHelper$1.__esModule = true; +wrapHelper$1.wrapHelper = wrapHelper; + +function wrapHelper(helper, transformOptionsFn) { + if (typeof helper !== 'function') { + // This should not happen, but apparently it does in https://github.com/wycats/handlebars.js/issues/1639 + // We try to make the wrapper least-invasive by not wrapping it, if the helper is not a function. + return helper; + } + var wrapper = function wrapper() /* dynamic arguments */{ + var options = arguments[arguments.length - 1]; + arguments[arguments.length - 1] = transformOptionsFn(options); + return helper.apply(this, arguments); + }; + return wrapper; +} + +runtime$1.__esModule = true; +runtime$1.checkRevision = checkRevision; +runtime$1.template = template; +runtime$1.wrapProgram = wrapProgram; +runtime$1.resolvePartial = resolvePartial; +runtime$1.invokePartial = invokePartial; +runtime$1.noop = noop; +// istanbul ignore next + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + +// istanbul ignore next + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } } + +var _utils = utils; + +var Utils = _interopRequireWildcard(_utils); + +var _exception = exception.exports; + +var _exception2 = _interopRequireDefault(_exception); + +var _base = base; + +var _helpers = helpers; + +var _internalWrapHelper = wrapHelper$1; + +var _internalProtoAccess = protoAccess; + +function checkRevision(compilerInfo) { + var compilerRevision = compilerInfo && compilerInfo[0] || 1, + currentRevision = _base.COMPILER_REVISION; + + if (compilerRevision >= _base.LAST_COMPATIBLE_COMPILER_REVISION && compilerRevision <= _base.COMPILER_REVISION) { + return; + } + + if (compilerRevision < _base.LAST_COMPATIBLE_COMPILER_REVISION) { + var runtimeVersions = _base.REVISION_CHANGES[currentRevision], + compilerVersions = _base.REVISION_CHANGES[compilerRevision]; + throw new _exception2['default']('Template was precompiled with an older version of Handlebars than the current runtime. ' + 'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').'); + } else { + // Use the embedded version info since the runtime doesn't know about this revision yet + throw new _exception2['default']('Template was precompiled with a newer version of Handlebars than the current runtime. ' + 'Please update your runtime to a newer version (' + compilerInfo[1] + ').'); + } +} + +function template(templateSpec, env) { + /* istanbul ignore next */ + if (!env) { + throw new _exception2['default']('No environment passed to template'); + } + if (!templateSpec || !templateSpec.main) { + throw new _exception2['default']('Unknown template object: ' + typeof templateSpec); + } + + templateSpec.main.decorator = templateSpec.main_d; + + // Note: Using env.VM references rather than local var references throughout this section to allow + // for external users to override these as pseudo-supported APIs. + env.VM.checkRevision(templateSpec.compiler); + + // backwards compatibility for precompiled templates with compiler-version 7 (<4.3.0) + var templateWasPrecompiledWithCompilerV7 = templateSpec.compiler && templateSpec.compiler[0] === 7; + + function invokePartialWrapper(partial, context, options) { + if (options.hash) { + context = Utils.extend({}, context, options.hash); + if (options.ids) { + options.ids[0] = true; + } + } + partial = env.VM.resolvePartial.call(this, partial, context, options); + + var extendedOptions = Utils.extend({}, options, { + hooks: this.hooks, + protoAccessControl: this.protoAccessControl + }); + + var result = env.VM.invokePartial.call(this, partial, context, extendedOptions); + + if (result == null && env.compile) { + options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env); + result = options.partials[options.name](context, extendedOptions); + } + if (result != null) { + if (options.indent) { + var lines = result.split('\n'); + for (var i = 0, l = lines.length; i < l; i++) { + if (!lines[i] && i + 1 === l) { + break; + } + + lines[i] = options.indent + lines[i]; + } + result = lines.join('\n'); + } + return result; + } else { + throw new _exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode'); + } + } + + // Just add water + var container = { + strict: function strict(obj, name, loc) { + if (!obj || !(name in obj)) { + throw new _exception2['default']('"' + name + '" not defined in ' + obj, { + loc: loc + }); + } + return container.lookupProperty(obj, name); + }, + lookupProperty: function lookupProperty(parent, propertyName) { + var result = parent[propertyName]; + if (result == null) { + return result; + } + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return result; + } + + if (_internalProtoAccess.resultIsAllowed(result, container.protoAccessControl, propertyName)) { + return result; + } + return undefined; + }, + lookup: function lookup(depths, name) { + var len = depths.length; + for (var i = 0; i < len; i++) { + var result = depths[i] && container.lookupProperty(depths[i], name); + if (result != null) { + return depths[i][name]; + } + } + }, + lambda: function lambda(current, context) { + return typeof current === 'function' ? current.call(context) : current; + }, + + escapeExpression: Utils.escapeExpression, + invokePartial: invokePartialWrapper, + + fn: function fn(i) { + var ret = templateSpec[i]; + ret.decorator = templateSpec[i + '_d']; + return ret; + }, + + programs: [], + program: function program(i, data, declaredBlockParams, blockParams, depths) { + var programWrapper = this.programs[i], + fn = this.fn(i); + if (data || depths || blockParams || declaredBlockParams) { + programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths); + } else if (!programWrapper) { + programWrapper = this.programs[i] = wrapProgram(this, i, fn); + } + return programWrapper; + }, + + data: function data(value, depth) { + while (value && depth--) { + value = value._parent; + } + return value; + }, + mergeIfNeeded: function mergeIfNeeded(param, common) { + var obj = param || common; + + if (param && common && param !== common) { + obj = Utils.extend({}, common, param); + } + + return obj; + }, + // An empty object to use as replacement for null-contexts + nullContext: Object.seal({}), + + noop: env.VM.noop, + compilerInfo: templateSpec.compiler + }; + + function ret(context) { + var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; + + var data = options.data; + + ret._setup(options); + if (!options.partial && templateSpec.useData) { + data = initData(context, data); + } + var depths = undefined, + blockParams = templateSpec.useBlockParams ? [] : undefined; + if (templateSpec.useDepths) { + if (options.depths) { + depths = context != options.depths[0] ? [context].concat(options.depths) : options.depths; + } else { + depths = [context]; + } + } + + function main(context /*, options*/) { + return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths); + } + + main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams); + return main(context, options); + } + + ret.isTop = true; + + ret._setup = function (options) { + if (!options.partial) { + var mergedHelpers = Utils.extend({}, env.helpers, options.helpers); + wrapHelpersToPassLookupProperty(mergedHelpers, container); + container.helpers = mergedHelpers; + + if (templateSpec.usePartial) { + // Use mergeIfNeeded here to prevent compiling global partials multiple times + container.partials = container.mergeIfNeeded(options.partials, env.partials); + } + if (templateSpec.usePartial || templateSpec.useDecorators) { + container.decorators = Utils.extend({}, env.decorators, options.decorators); + } + + container.hooks = {}; + container.protoAccessControl = _internalProtoAccess.createProtoAccessControl(options); + + var keepHelperInHelpers = options.allowCallsToHelperMissing || templateWasPrecompiledWithCompilerV7; + _helpers.moveHelperToHooks(container, 'helperMissing', keepHelperInHelpers); + _helpers.moveHelperToHooks(container, 'blockHelperMissing', keepHelperInHelpers); + } else { + container.protoAccessControl = options.protoAccessControl; // internal option + container.helpers = options.helpers; + container.partials = options.partials; + container.decorators = options.decorators; + container.hooks = options.hooks; + } + }; + + ret._child = function (i, data, blockParams, depths) { + if (templateSpec.useBlockParams && !blockParams) { + throw new _exception2['default']('must pass block params'); + } + if (templateSpec.useDepths && !depths) { + throw new _exception2['default']('must pass parent depths'); + } + + return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths); + }; + return ret; +} + +function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) { + function prog(context) { + var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; + + var currentDepths = depths; + if (depths && context != depths[0] && !(context === container.nullContext && depths[0] === null)) { + currentDepths = [context].concat(depths); + } + + return fn(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), currentDepths); + } + + prog = executeDecorators(fn, prog, container, depths, data, blockParams); + + prog.program = i; + prog.depth = depths ? depths.length : 0; + prog.blockParams = declaredBlockParams || 0; + return prog; +} + +/** + * This is currently part of the official API, therefore implementation details should not be changed. + */ + +function resolvePartial(partial, context, options) { + if (!partial) { + if (options.name === '@partial-block') { + partial = options.data['partial-block']; + } else { + partial = options.partials[options.name]; + } + } else if (!partial.call && !options.name) { + // This is a dynamic partial that returned a string + options.name = partial; + partial = options.partials[partial]; + } + return partial; +} + +function invokePartial(partial, context, options) { + // Use the current closure context to save the partial-block if this partial + var currentPartialBlock = options.data && options.data['partial-block']; + options.partial = true; + if (options.ids) { + options.data.contextPath = options.ids[0] || options.data.contextPath; + } + + var partialBlock = undefined; + if (options.fn && options.fn !== noop) { + (function () { + options.data = _base.createFrame(options.data); + // Wrapper function to get access to currentPartialBlock from the closure + var fn = options.fn; + partialBlock = options.data['partial-block'] = function partialBlockWrapper(context) { + var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; + + // Restore the partial-block from the closure for the execution of the block + // i.e. the part inside the block of the partial call. + options.data = _base.createFrame(options.data); + options.data['partial-block'] = currentPartialBlock; + return fn(context, options); + }; + if (fn.partials) { + options.partials = Utils.extend({}, options.partials, fn.partials); + } + })(); + } + + if (partial === undefined && partialBlock) { + partial = partialBlock; + } + + if (partial === undefined) { + throw new _exception2['default']('The partial ' + options.name + ' could not be found'); + } else if (partial instanceof Function) { + return partial(context, options); + } +} + +function noop() { + return ''; +} + +function initData(context, data) { + if (!data || !('root' in data)) { + data = data ? _base.createFrame(data) : {}; + data.root = context; + } + return data; +} + +function executeDecorators(fn, prog, container, depths, data, blockParams) { + if (fn.decorator) { + var props = {}; + prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths); + Utils.extend(prog, props); + } + return prog; +} + +function wrapHelpersToPassLookupProperty(mergedHelpers, container) { + Object.keys(mergedHelpers).forEach(function (helperName) { + var helper = mergedHelpers[helperName]; + mergedHelpers[helperName] = passLookupPropertyOption(helper, container); + }); +} + +function passLookupPropertyOption(helper, container) { + var lookupProperty = container.lookupProperty; + return _internalWrapHelper.wrapHelper(helper, function (options) { + return Utils.extend({ lookupProperty: lookupProperty }, options); + }); +} + +var noConflict = {exports: {}}; + +(function (module, exports) { + + exports.__esModule = true; + + exports['default'] = function (Handlebars) { + /* istanbul ignore next */ + var root = typeof commonjsGlobal !== 'undefined' ? commonjsGlobal : window, + $Handlebars = root.Handlebars; + /* istanbul ignore next */ + Handlebars.noConflict = function () { + if (root.Handlebars === Handlebars) { + root.Handlebars = $Handlebars; + } + return Handlebars; + }; + }; + + module.exports = exports['default']; + +} (noConflict, noConflict.exports)); + +(function (module, exports) { + + exports.__esModule = true; + // istanbul ignore next + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + // istanbul ignore next + + function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } } + + var _handlebarsBase = base; + + var base$1 = _interopRequireWildcard(_handlebarsBase); + + // Each of these augment the Handlebars object. No need to setup here. + // (This is done to easily share code between commonjs and browse envs) + + var _handlebarsSafeString = safeString.exports; + + var _handlebarsSafeString2 = _interopRequireDefault(_handlebarsSafeString); + + var _handlebarsException = exception.exports; + + var _handlebarsException2 = _interopRequireDefault(_handlebarsException); + + var _handlebarsUtils = utils; + + var Utils = _interopRequireWildcard(_handlebarsUtils); + + var _handlebarsRuntime = runtime$1; + + var runtime = _interopRequireWildcard(_handlebarsRuntime); + + var _handlebarsNoConflict = noConflict.exports; + + var _handlebarsNoConflict2 = _interopRequireDefault(_handlebarsNoConflict); + + // For compatibility and usage outside of module systems, make the Handlebars object a namespace + function create() { + var hb = new base$1.HandlebarsEnvironment(); + + Utils.extend(hb, base$1); + hb.SafeString = _handlebarsSafeString2['default']; + hb.Exception = _handlebarsException2['default']; + hb.Utils = Utils; + hb.escapeExpression = Utils.escapeExpression; + + hb.VM = runtime; + hb.template = function (spec) { + return runtime.template(spec, hb); + }; + + return hb; + } + + var inst = create(); + inst.create = create; + + _handlebarsNoConflict2['default'](inst); + + inst['default'] = inst; + + exports['default'] = inst; + module.exports = exports['default']; + +} (handlebars_runtime, handlebars_runtime.exports)); + +// Create a simple path alias to allow browserify to resolve +// the runtime on a supported path. +var runtime = handlebars_runtime.exports['default']; + +var templateClient = {"1":function(container,depth0,helpers,partials,data) { + return "import { NgModule} from '@angular/core';\nimport { HttpClientModule } from '@angular/common/http';\n\nimport { AngularHttpRequest } from './core/AngularHttpRequest';\nimport { BaseHttpRequest } from './core/BaseHttpRequest';\nimport type { OpenAPIConfig } from './core/OpenAPI';\nimport { OpenAPI } from './core/OpenAPI';\n"; +},"3":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "import type { BaseHttpRequest } from './core/BaseHttpRequest';\nimport type { OpenAPIConfig } from './core/OpenAPI';\nimport { " + + ((stack1 = (((helper = lookupProperty(helpers,"httpRequest") || alias1(depth0, "httpRequest", {"start":{"line":14,"column":12},"end":{"line":14,"column":23}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"httpRequest","hash":{},"data":data,"loc":{"start":{"line":14,"column":9},"end":{"line":14,"column":26}}}) : helper))) != null ? stack1 : "") + + " } from './core/" + + ((stack1 = (((helper = lookupProperty(helpers,"httpRequest") || alias1(depth0, "httpRequest", {"start":{"line":14,"column":45},"end":{"line":14,"column":56}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"httpRequest","hash":{},"data":data,"loc":{"start":{"line":14,"column":42},"end":{"line":14,"column":59}}}) : helper))) != null ? stack1 : "") + + "';\n"; +},"5":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"each").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"services"),{"name":"each","hash":{},"fn":container.program(6, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":18,"column":0},"end":{"line":20,"column":9}}})) != null ? stack1 : ""); +},"6":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", alias4=container.lambda, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "import { " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":19,"column":12},"end":{"line":19,"column":16}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":19,"column":9},"end":{"line":19,"column":19}}}) : helper))) != null ? stack1 : "") + + ((stack1 = alias4(alias1(lookupProperty(data,"root"), "postfix", {"start":{"line":19,"column":22},"end":{"line":19,"column":35}} ), depth0)) != null ? stack1 : "") + + " } from './services/" + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":19,"column":61},"end":{"line":19,"column":65}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":19,"column":58},"end":{"line":19,"column":68}}}) : helper))) != null ? stack1 : "") + + ((stack1 = alias4(alias1(lookupProperty(data,"root"), "postfix", {"start":{"line":19,"column":71},"end":{"line":19,"column":84}} ), depth0)) != null ? stack1 : "") + + "';\n"; +},"8":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "@NgModule({\n imports: [HttpClientModule],\n providers: [\n {\n provide: OpenAPI,\n useValue: {\n BASE: OpenAPI?.BASE ?? '" + + ((stack1 = (((helper = lookupProperty(helpers,"server") || alias1(depth0, "server", {"start":{"line":30,"column":31},"end":{"line":30,"column":37}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"server","hash":{},"data":data,"loc":{"start":{"line":30,"column":28},"end":{"line":30,"column":40}}}) : helper))) != null ? stack1 : "") + + "',\n VERSION: OpenAPI?.VERSION ?? '" + + ((stack1 = (((helper = lookupProperty(helpers,"version") || alias1(depth0, "version", {"start":{"line":31,"column":37},"end":{"line":31,"column":44}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"version","hash":{},"data":data,"loc":{"start":{"line":31,"column":34},"end":{"line":31,"column":47}}}) : helper))) != null ? stack1 : "") + + "',\n WITH_CREDENTIALS: OpenAPI?.WITH_CREDENTIALS ?? false,\n CREDENTIALS: OpenAPI?.CREDENTIALS ?? 'include',\n TOKEN: OpenAPI?.TOKEN,\n USERNAME: OpenAPI?.USERNAME,\n PASSWORD: OpenAPI?.PASSWORD,\n HEADERS: OpenAPI?.HEADERS,\n ENCODE_PATH: OpenAPI?.ENCODE_PATH,\n } as OpenAPIConfig,\n },\n {\n provide: BaseHttpRequest,\n useClass: AngularHttpRequest,\n },\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias2,lookupProperty(depth0,"services"),{"name":"each","hash":{},"fn":container.program(9, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":45,"column":2},"end":{"line":47,"column":11}}})) != null ? stack1 : "") + + " ]\n})\nexport class " + + ((stack1 = (((helper = lookupProperty(helpers,"clientName") || alias1(depth0, "clientName", {"start":{"line":50,"column":16},"end":{"line":50,"column":26}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"clientName","hash":{},"data":data,"loc":{"start":{"line":50,"column":13},"end":{"line":50,"column":29}}}) : helper))) != null ? stack1 : "") + + " {}\n"; +},"9":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":46,"column":5},"end":{"line":46,"column":9}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"name","hash":{},"data":data,"loc":{"start":{"line":46,"column":2},"end":{"line":46,"column":12}}}) : helper))) != null ? stack1 : "") + + ((stack1 = container.lambda(alias1(lookupProperty(data,"root"), "postfix", {"start":{"line":46,"column":15},"end":{"line":46,"column":28}} ), depth0)) != null ? stack1 : "") + + ",\n"; +},"11":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;\n\nexport class " + + ((stack1 = (((helper = lookupProperty(helpers,"clientName") || alias1(depth0, "clientName", {"start":{"line":54,"column":16},"end":{"line":54,"column":26}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"clientName","hash":{},"data":data,"loc":{"start":{"line":54,"column":13},"end":{"line":54,"column":29}}}) : helper))) != null ? stack1 : "") + + " {\n\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias2,lookupProperty(depth0,"services"),{"name":"each","hash":{},"fn":container.program(12, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":56,"column":1},"end":{"line":58,"column":10}}})) != null ? stack1 : "") + + "\n public readonly request: BaseHttpRequest;\n\n constructor(config?: Partial, HttpRequest: HttpRequestConstructor = " + + ((stack1 = (((helper = lookupProperty(helpers,"httpRequest") || alias1(depth0, "httpRequest", {"start":{"line":62,"column":87},"end":{"line":62,"column":98}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"httpRequest","hash":{},"data":data,"loc":{"start":{"line":62,"column":84},"end":{"line":62,"column":101}}}) : helper))) != null ? stack1 : "") + + ") {\n this.request = new HttpRequest({\n BASE: config?.BASE ?? '" + + ((stack1 = (((helper = lookupProperty(helpers,"server") || alias1(depth0, "server", {"start":{"line":64,"column":29},"end":{"line":64,"column":35}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"server","hash":{},"data":data,"loc":{"start":{"line":64,"column":26},"end":{"line":64,"column":38}}}) : helper))) != null ? stack1 : "") + + "',\n VERSION: config?.VERSION ?? '" + + ((stack1 = (((helper = lookupProperty(helpers,"version") || alias1(depth0, "version", {"start":{"line":65,"column":35},"end":{"line":65,"column":42}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"version","hash":{},"data":data,"loc":{"start":{"line":65,"column":32},"end":{"line":65,"column":45}}}) : helper))) != null ? stack1 : "") + + "',\n WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,\n CREDENTIALS: config?.CREDENTIALS ?? 'include',\n TOKEN: config?.TOKEN,\n USERNAME: config?.USERNAME,\n PASSWORD: config?.PASSWORD,\n HEADERS: config?.HEADERS,\n ENCODE_PATH: config?.ENCODE_PATH,\n });\n\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias2,lookupProperty(depth0,"services"),{"name":"each","hash":{},"fn":container.program(14, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":75,"column":2},"end":{"line":77,"column":11}}})) != null ? stack1 : "") + + " }\n}\n"; +},"12":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), alias2=container.strict, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " public readonly " + + ((stack1 = lookupProperty(helpers,"camelCase").call(alias1,lookupProperty(depth0,"name"),{"name":"camelCase","hash":{},"data":data,"loc":{"start":{"line":57,"column":17},"end":{"line":57,"column":37}}})) != null ? stack1 : "") + + ": " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias2(depth0, "name", {"start":{"line":57,"column":42},"end":{"line":57,"column":46}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":57,"column":39},"end":{"line":57,"column":49}}}) : helper))) != null ? stack1 : "") + + ((stack1 = container.lambda(alias2(lookupProperty(data,"root"), "postfix", {"start":{"line":57,"column":52},"end":{"line":57,"column":65}} ), depth0)) != null ? stack1 : "") + + ";\n"; +},"14":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), alias2=container.strict, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " this." + + ((stack1 = lookupProperty(helpers,"camelCase").call(alias1,lookupProperty(depth0,"name"),{"name":"camelCase","hash":{},"data":data,"loc":{"start":{"line":76,"column":7},"end":{"line":76,"column":27}}})) != null ? stack1 : "") + + " = new " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias2(depth0, "name", {"start":{"line":76,"column":37},"end":{"line":76,"column":41}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":76,"column":34},"end":{"line":76,"column":44}}}) : helper))) != null ? stack1 : "") + + ((stack1 = container.lambda(alias2(lookupProperty(data,"root"), "postfix", {"start":{"line":76,"column":47},"end":{"line":76,"column":60}} ), depth0)) != null ? stack1 : "") + + "(this.request);\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n" + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"angular",{"name":"equals","hash":{},"fn":container.program(1, data, 0),"inverse":container.program(3, data, 0),"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":15,"column":11}}})) != null ? stack1 : "") + + "\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"services"),{"name":"if","hash":{},"fn":container.program(5, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":17,"column":0},"end":{"line":21,"column":7}}})) != null ? stack1 : "") + + "\n" + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"angular",{"name":"equals","hash":{},"fn":container.program(8, data, 0),"inverse":container.program(11, data, 0),"data":data,"loc":{"start":{"line":23,"column":0},"end":{"line":80,"column":11}}})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var angularGetHeaders = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getHeaders = (config: OpenAPIConfig, options: ApiRequestOptions): Observable => {\n return forkJoin({\n token: resolve(options, config.TOKEN),\n username: resolve(options, config.USERNAME),\n password: resolve(options, config.PASSWORD),\n additionalHeaders: resolve(options, config.HEADERS),\n }).pipe(\n map(({ token, username, password, additionalHeaders }) => {\n const headers = Object.entries({\n Accept: 'application/json',\n ...additionalHeaders,\n ...options.headers,\n })\n .filter(([_, value]) => isDefined(value))\n .reduce((headers, [key, value]) => ({\n ...headers,\n [key]: String(value),\n }), {} as Record);\n\n if (isStringWithValue(token)) {\n headers['Authorization'] = `Bearer ${token}`;\n }\n\n if (isStringWithValue(username) && isStringWithValue(password)) {\n const credentials = base64(`${username}:${password}`);\n headers['Authorization'] = `Basic ${credentials}`;\n }\n\n if (options.body) {\n if (options.mediaType) {\n headers['Content-Type'] = options.mediaType;\n } else if (isBlob(options.body)) {\n headers['Content-Type'] = options.body.type || 'application/octet-stream';\n } else if (isString(options.body)) {\n headers['Content-Type'] = 'text/plain';\n } else if (!isFormData(options.body)) {\n headers['Content-Type'] = 'application/json';\n }\n }\n\n return new HttpHeaders(headers);\n }),\n );\n};"; +},"useData":true}; + +var angularGetRequestBody = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getRequestBody = (options: ApiRequestOptions): any => { if (options.body) { if\n(options.mediaType?.includes('/json')) { return JSON.stringify(options.body) } else if (isString(options.body) ||\nisBlob(options.body) || isFormData(options.body)) { return options.body; } else { return JSON.stringify(options.body); }\n} return undefined; };"; +},"useData":true}; + +var angularGetResponseBody = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getResponseBody = (response: HttpResponse): T | undefined => {\n if (response.status !== 204 && response.body !== null) {\n return response.body;\n }\n return undefined;\n};"; +},"useData":true}; + +var angularGetResponseHeader = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getResponseHeader = (response: HttpResponse, responseHeader?: string): string | undefined => {\n if (responseHeader) {\n const value = response.headers.get(responseHeader);\n if (isString(value)) {\n return value;\n }\n }\n return undefined;\n};"; +},"useData":true}; + +var angularRequest = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\nimport type { HttpResponse, HttpErrorResponse } from '@angular/common/http';\nimport { forkJoin, of, throwError } from 'rxjs';\nimport { catchError, map, switchMap } from 'rxjs/operators';\nimport type { Observable } from 'rxjs';\n\nimport { ApiError } from './ApiError';\nimport type { ApiRequestOptions } from './ApiRequestOptions';\nimport type { ApiResult } from './ApiResult';\nimport type { OpenAPIConfig } from './OpenAPI';\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isDefined"),depth0,{"name":"functions/isDefined","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isString"),depth0,{"name":"functions/isString","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isStringWithValue"),depth0,{"name":"functions/isStringWithValue","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isBlob"),depth0,{"name":"functions/isBlob","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isFormData"),depth0,{"name":"functions/isFormData","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/base64"),depth0,{"name":"functions/base64","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getQueryString"),depth0,{"name":"functions/getQueryString","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getUrl"),depth0,{"name":"functions/getUrl","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getFormData"),depth0,{"name":"functions/getFormData","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/resolve"),depth0,{"name":"functions/resolve","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"angular/getHeaders"),depth0,{"name":"angular/getHeaders","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"angular/getRequestBody"),depth0,{"name":"angular/getRequestBody","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"angular/sendRequest"),depth0,{"name":"angular/sendRequest","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"angular/getResponseHeader"),depth0,{"name":"angular/getResponseHeader","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"angular/getResponseBody"),depth0,{"name":"angular/getResponseBody","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/catchErrorCodes"),depth0,{"name":"functions/catchErrorCodes","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n/**\n * Request method\n * @param config The OpenAPI configuration object\n * @param http The Angular HTTP client\n * @param options The request options from the service\n * @returns Observable\n * @throws ApiError\n */\nexport const request = (config: OpenAPIConfig, http: HttpClient, options: ApiRequestOptions): Observable => {\n const url = getUrl(config, options);\n const formData = getFormData(options);\n const body = getRequestBody(options);\n\n return getHeaders(config, options).pipe(\n switchMap(headers => {\n return sendRequest(config, options, http, url, formData, body, headers);\n }),\n map(response => {\n const responseBody = getResponseBody(response);\n const responseHeader = getResponseHeader(response, options.responseHeader);\n return {\n url,\n ok: response.ok,\n status: response.status,\n statusText: response.statusText,\n body: responseHeader ?? responseBody,\n } as ApiResult;\n }),\n catchError((error: HttpErrorResponse) => {\n if (!error.status) {\n return throwError(error);\n }\n return of({\n url,\n ok: error.ok,\n status: error.status,\n statusText: error.statusText,\n body: error.error ?? error.statusText,\n } as ApiResult);\n }),\n map(result => {\n catchErrorCodes(options, result);\n return result.body as T;\n }),\n catchError((error: ApiError) => {\n return throwError(error);\n }),\n );\n};"; +},"usePartial":true,"useData":true}; + +var angularSendRequest = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "export const sendRequest = (\n config: OpenAPIConfig,\n options: ApiRequestOptions,\n http: HttpClient,\n url: string,\n body: any,\n formData: FormData | undefined,\n headers: HttpHeaders\n): Observable> => {\n return http.request(options.method, url, {\n headers,\n body: body ?? formData,\n withCredentials: config.WITH_CREDENTIALS,\n observe: 'response',\n });\n};"; +},"useData":true}; + +var templateCoreApiError = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\nimport type { ApiRequestOptions } from './ApiRequestOptions';\nimport type { ApiResult } from './ApiResult';\n\nexport class ApiError extends Error {\n public readonly url: string;\n public readonly status: number;\n public readonly statusText: string;\n public readonly body: any;\n public readonly request: ApiRequestOptions;\n\n constructor(request: ApiRequestOptions, response: ApiResult, message: string) {\n super(message);\n\n this.name = 'ApiError';\n this.url = response.url;\n this.status = response.status;\n this.statusText = response.statusText;\n this.body = response.body;\n this.request = request;\n }\n}"; +},"usePartial":true,"useData":true}; + +var templateCoreApiRequestOptions = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\nexport type ApiRequestOptions = {\n readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';\n readonly url: string;\n readonly path?: Record;\n readonly cookies?: Record;\n readonly headers?: Record;\n readonly query?: Record;\n readonly formData?: Record;\n readonly body?: any;\n readonly mediaType?: string;\n readonly responseHeader?: string;\n readonly errors?: Record;\n};"; +},"usePartial":true,"useData":true}; + +var templateCoreApiResult = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\nexport type ApiResult = {\n readonly url: string;\n readonly ok: boolean;\n readonly status: number;\n readonly statusText: string;\n readonly body: any;\n};"; +},"usePartial":true,"useData":true}; + +var axiosGetHeaders = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getHeaders = async (config: OpenAPIConfig, options: ApiRequestOptions, formData?: FormData): Promise> => {\n const token = await resolve(options, config.TOKEN);\n const username = await resolve(options, config.USERNAME);\n const password = await resolve(options, config.PASSWORD);\n const additionalHeaders = await resolve(options, config.HEADERS);\n const formHeaders = typeof formData?.getHeaders === 'function' && formData?.getHeaders() || {}\n\n const headers = Object.entries({\n Accept: 'application/json',\n ...additionalHeaders,\n ...options.headers,\n ...formHeaders,\n })\n .filter(([_, value]) => isDefined(value))\n .reduce((headers, [key, value]) => ({\n ...headers,\n [key]: String(value),\n }), {} as Record);\n\n if (isStringWithValue(token)) {\n headers['Authorization'] = `Bearer ${token}`;\n }\n\n if (isStringWithValue(username) && isStringWithValue(password)) {\n const credentials = base64(`${username}:${password}`);\n headers['Authorization'] = `Basic ${credentials}`;\n }\n\n if (options.body) {\n if (options.mediaType) {\n headers['Content-Type'] = options.mediaType;\n } else if (isBlob(options.body)) {\n headers['Content-Type'] = options.body.type || 'application/octet-stream';\n } else if (isString(options.body)) {\n headers['Content-Type'] = 'text/plain';\n } else if (!isFormData(options.body)) {\n headers['Content-Type'] = 'application/json';\n }\n }\n\n return headers;\n};"; +},"useData":true}; + +var axiosGetRequestBody = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getRequestBody = (options: ApiRequestOptions): any => { if (options.body) { return options.body; } return\nundefined; };"; +},"useData":true}; + +var axiosGetResponseBody = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getResponseBody = (response: AxiosResponse): any => {\n if (response.status !== 204) {\n return response.data;\n }\n return undefined;\n};"; +},"useData":true}; + +var axiosGetResponseHeader = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getResponseHeader = (response: AxiosResponse, responseHeader?: string): string | undefined => {\n if (responseHeader) {\n const content = response.headers[responseHeader];\n if (isString(content)) {\n return content;\n }\n }\n return undefined;\n};"; +},"useData":true}; + +var axiosRequest = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\nimport axios from 'axios';\nimport type { AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios';\nimport FormData from 'form-data';\n\nimport { ApiError } from './ApiError';\nimport type { ApiRequestOptions } from './ApiRequestOptions';\nimport type { ApiResult } from './ApiResult';\nimport { CancelablePromise } from './CancelablePromise';\nimport type { OnCancel } from './CancelablePromise';\nimport type { OpenAPIConfig } from './OpenAPI';\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isDefined"),depth0,{"name":"functions/isDefined","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isString"),depth0,{"name":"functions/isString","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isStringWithValue"),depth0,{"name":"functions/isStringWithValue","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isBlob"),depth0,{"name":"functions/isBlob","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isFormData"),depth0,{"name":"functions/isFormData","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isSuccess"),depth0,{"name":"functions/isSuccess","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/base64"),depth0,{"name":"functions/base64","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getQueryString"),depth0,{"name":"functions/getQueryString","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getUrl"),depth0,{"name":"functions/getUrl","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getFormData"),depth0,{"name":"functions/getFormData","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/resolve"),depth0,{"name":"functions/resolve","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"axios/getHeaders"),depth0,{"name":"axios/getHeaders","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"axios/getRequestBody"),depth0,{"name":"axios/getRequestBody","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"axios/sendRequest"),depth0,{"name":"axios/sendRequest","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"axios/getResponseHeader"),depth0,{"name":"axios/getResponseHeader","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"axios/getResponseBody"),depth0,{"name":"axios/getResponseBody","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/catchErrorCodes"),depth0,{"name":"functions/catchErrorCodes","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n/**\n * Request method\n * @param config The OpenAPI configuration object\n * @param options The request options from the service\n * @returns CancelablePromise\n * @throws ApiError\n */\nexport const request = (config: OpenAPIConfig, options: ApiRequestOptions): CancelablePromise => {\n return new CancelablePromise(async (resolve, reject, onCancel) => {\n try {\n const url = getUrl(config, options);\n const formData = getFormData(options);\n const body = getRequestBody(options);\n const headers = await getHeaders(config, options, formData);\n\n if (!onCancel.isCancelled) {\n const response = await sendRequest(config, options, url, body, formData, headers, onCancel);\n const responseBody = getResponseBody(response);\n const responseHeader = getResponseHeader(response, options.responseHeader);\n\n const result: ApiResult = {\n url,\n ok: isSuccess(response.status),\n status: response.status,\n statusText: response.statusText,\n body: responseHeader ?? responseBody,\n };\n\n catchErrorCodes(options, result);\n\n resolve(result.body);\n }\n } catch (error) {\n reject(error);\n }\n });\n};"; +},"usePartial":true,"useData":true}; + +var axiosSendRequest = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const sendRequest = async (\n config: OpenAPIConfig,\n options: ApiRequestOptions,\n url: string,\n body: any,\n formData: FormData | undefined,\n headers: Record,\n onCancel: OnCancel\n): Promise> => {\n const source = axios.CancelToken.source();\n\n const requestConfig: AxiosRequestConfig = {\n url,\n headers,\n data: body ?? formData,\n method: options.method,\n withCredentials: config.WITH_CREDENTIALS,\n cancelToken: source.token,\n };\n\n onCancel(() => source.cancel('The user aborted a request.'));\n\n try {\n return await axios.request(requestConfig);\n } catch (error) {\n const axiosError = error as AxiosError;\n if (axiosError.response) {\n return axiosError.response;\n }\n throw error;\n }\n};"; +},"useData":true}; + +var templateCoreBaseHttpRequest = {"1":function(container,depth0,helpers,partials,data) { + return "import type { HttpClient } from '@angular/common/http';\nimport type { Observable } from 'rxjs';\n\nimport type { ApiRequestOptions } from './ApiRequestOptions';\nimport type { OpenAPIConfig } from './OpenAPI';\n"; +},"3":function(container,depth0,helpers,partials,data) { + return "import type { ApiRequestOptions } from './ApiRequestOptions';\nimport type { CancelablePromise } from './CancelablePromise';\nimport type { OpenAPIConfig } from './OpenAPI';\n"; +},"5":function(container,depth0,helpers,partials,data) { + return " constructor(\n public readonly config: OpenAPIConfig,\n public readonly http: HttpClient,\n ) {}\n"; +},"7":function(container,depth0,helpers,partials,data) { + return " constructor(public readonly config: OpenAPIConfig) {}\n"; +},"9":function(container,depth0,helpers,partials,data) { + return " public abstract request(options: ApiRequestOptions): Observable;\n"; +},"11":function(container,depth0,helpers,partials,data) { + return " public abstract request(options: ApiRequestOptions): CancelablePromise;\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n" + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"angular",{"name":"equals","hash":{},"fn":container.program(1, data, 0),"inverse":container.program(3, data, 0),"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":13,"column":11}}})) != null ? stack1 : "") + + "\nexport abstract class BaseHttpRequest {\n\n" + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"angular",{"name":"equals","hash":{},"fn":container.program(5, data, 0),"inverse":container.program(7, data, 0),"data":data,"loc":{"start":{"line":17,"column":1},"end":{"line":24,"column":12}}})) != null ? stack1 : "") + + "\n" + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"angular",{"name":"equals","hash":{},"fn":container.program(9, data, 0),"inverse":container.program(11, data, 0),"data":data,"loc":{"start":{"line":26,"column":1},"end":{"line":30,"column":12}}})) != null ? stack1 : "") + + "}"; +},"usePartial":true,"useData":true}; + +var templateCancelablePromise = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\nexport class CancelError extends Error {\n\n constructor(message: string) {\n super(message);\n this.name = 'CancelError';\n }\n\n public get isCancelled(): boolean {\n return true;\n }\n}\n\nexport interface OnCancel {\n readonly isResolved: boolean;\n readonly isRejected: boolean;\n readonly isCancelled: boolean;\n\n (cancelHandler: () => void): void;\n}\n\nexport class CancelablePromise implements Promise {\n readonly [Symbol.toStringTag]!: string;\n\n private _isResolved: boolean;\n private _isRejected: boolean;\n private _isCancelled: boolean;\n private readonly _cancelHandlers: (() => void)[];\n private readonly _promise: Promise;\n private _resolve?: (value: T | PromiseLike) => void;\n private _reject?: (reason?: any) => void;\n\n constructor(\n executor: (\n resolve: (value: T | PromiseLike) => void,\n reject: (reason?: any) => void,\n onCancel: OnCancel\n ) => void\n ) {\n this._isResolved = false;\n this._isRejected = false;\n this._isCancelled = false;\n this._cancelHandlers = [];\n this._promise = new Promise((resolve, reject) => {\n this._resolve = resolve;\n this._reject = reject;\n\n const onResolve = (value: T | PromiseLike): void => {\n if (this._isResolved || this._isRejected || this._isCancelled) {\n return;\n }\n this._isResolved = true;\n this._resolve?.(value);\n };\n\n const onReject = (reason?: any): void => {\n if (this._isResolved || this._isRejected || this._isCancelled) {\n return;\n }\n this._isRejected = true;\n this._reject?.(reason);\n };\n\n const onCancel = (cancelHandler: () => void): void => {\n if (this._isResolved || this._isRejected || this._isCancelled) {\n return;\n }\n this._cancelHandlers.push(cancelHandler);\n };\n\n Object.defineProperty(onCancel, 'isResolved', {\n get: (): boolean => this._isResolved,\n });\n\n Object.defineProperty(onCancel, 'isRejected', {\n get: (): boolean => this._isRejected,\n });\n\n Object.defineProperty(onCancel, 'isCancelled', {\n get: (): boolean => this._isCancelled,\n });\n\n return executor(onResolve, onReject, onCancel as OnCancel);\n });\n }\n\n public then(\n onFulfilled?: ((value: T) => TResult1 | PromiseLike) | null,\n onRejected?: ((reason: any) => TResult2 | PromiseLike) | null\n ): Promise {\n return this._promise.then(onFulfilled, onRejected);\n }\n\n public catch(\n onRejected?: ((reason: any) => TResult | PromiseLike) | null\n ): Promise {\n return this._promise.catch(onRejected);\n }\n\n public finally(onFinally?: (() => void) | null): Promise {\n return this._promise.finally(onFinally);\n }\n\n public cancel(): void {\n if (this._isResolved || this._isRejected || this._isCancelled) {\n return;\n }\n this._isCancelled = true;\n if (this._cancelHandlers.length) {\n try {\n for (const cancelHandler of this._cancelHandlers) {\n cancelHandler();\n }\n } catch (error) {\n console.warn('Cancellation threw an error', error);\n return;\n }\n }\n this._cancelHandlers.length = 0;\n this._reject?.(new CancelError('Request aborted'));\n }\n\n public get isCancelled(): boolean {\n return this._isCancelled;\n }\n}"; +},"usePartial":true,"useData":true}; + +var fetchGetHeaders = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getHeaders = async (config: OpenAPIConfig, options: ApiRequestOptions): Promise => {\n const token = await resolve(options, config.TOKEN);\n const username = await resolve(options, config.USERNAME);\n const password = await resolve(options, config.PASSWORD);\n const additionalHeaders = await resolve(options, config.HEADERS);\n\n const headers = Object.entries({\n Accept: 'application/json',\n ...additionalHeaders,\n ...options.headers,\n })\n .filter(([_, value]) => isDefined(value))\n .reduce((headers, [key, value]) => ({\n ...headers,\n [key]: String(value),\n }), {} as Record);\n\n if (isStringWithValue(token)) {\n headers['Authorization'] = `Bearer ${token}`;\n }\n\n if (isStringWithValue(username) && isStringWithValue(password)) {\n const credentials = base64(`${username}:${password}`);\n headers['Authorization'] = `Basic ${credentials}`;\n }\n\n if (options.body) {\n if (options.mediaType) {\n headers['Content-Type'] = options.mediaType;\n } else if (isBlob(options.body)) {\n headers['Content-Type'] = options.body.type || 'application/octet-stream';\n } else if (isString(options.body)) {\n headers['Content-Type'] = 'text/plain';\n } else if (!isFormData(options.body)) {\n headers['Content-Type'] = 'application/json';\n }\n }\n\n return new Headers(headers);\n};"; +},"useData":true}; + +var fetchGetRequestBody = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getRequestBody = (options: ApiRequestOptions): any => { if (options.body !== undefined) { if\n(options.mediaType?.includes('/json')) { return JSON.stringify(options.body) } else if (isString(options.body) ||\nisBlob(options.body) || isFormData(options.body)) { return options.body; } else { return JSON.stringify(options.body); }\n} return undefined; };"; +},"useData":true}; + +var fetchGetResponseBody = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getResponseBody = async (response: Response): Promise => {\n if (response.status !== 204) {\n try {\n const contentType = response.headers.get('Content-Type');\n if (contentType) {\n const jsonTypes = ['application/json', 'application/problem+json']\n const isJSON = jsonTypes.some(type => contentType.toLowerCase().startsWith(type));\n if (isJSON) {\n return await response.json();\n } else {\n return await response.text();\n }\n }\n } catch (error) {\n console.error(error);\n }\n }\n return undefined;\n};"; +},"useData":true}; + +var fetchGetResponseHeader = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getResponseHeader = (response: Response, responseHeader?: string): string | undefined => { if (responseHeader) {\nconst content = response.headers.get(responseHeader); if (isString(content)) { return content; } } return undefined; };"; +},"useData":true}; + +var fetchRequest = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\nimport { ApiError } from './ApiError';\nimport type { ApiRequestOptions } from './ApiRequestOptions';\nimport type { ApiResult } from './ApiResult';\nimport { CancelablePromise } from './CancelablePromise';\nimport type { OnCancel } from './CancelablePromise';\nimport type { OpenAPIConfig } from './OpenAPI';\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isDefined"),depth0,{"name":"functions/isDefined","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isString"),depth0,{"name":"functions/isString","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isStringWithValue"),depth0,{"name":"functions/isStringWithValue","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isBlob"),depth0,{"name":"functions/isBlob","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isFormData"),depth0,{"name":"functions/isFormData","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/base64"),depth0,{"name":"functions/base64","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getQueryString"),depth0,{"name":"functions/getQueryString","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getUrl"),depth0,{"name":"functions/getUrl","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getFormData"),depth0,{"name":"functions/getFormData","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/resolve"),depth0,{"name":"functions/resolve","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"fetch/getHeaders"),depth0,{"name":"fetch/getHeaders","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"fetch/getRequestBody"),depth0,{"name":"fetch/getRequestBody","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"fetch/sendRequest"),depth0,{"name":"fetch/sendRequest","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"fetch/getResponseHeader"),depth0,{"name":"fetch/getResponseHeader","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"fetch/getResponseBody"),depth0,{"name":"fetch/getResponseBody","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/catchErrorCodes"),depth0,{"name":"functions/catchErrorCodes","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n/**\n * Request method\n * @param config The OpenAPI configuration object\n * @param options The request options from the service\n * @returns CancelablePromise\n * @throws ApiError\n */\nexport const request = (config: OpenAPIConfig, options: ApiRequestOptions): CancelablePromise => {\n return new CancelablePromise(async (resolve, reject, onCancel) => {\n try {\n const url = getUrl(config, options);\n const formData = getFormData(options);\n const body = getRequestBody(options);\n const headers = await getHeaders(config, options);\n\n if (!onCancel.isCancelled) {\n const response = await sendRequest(config, options, url, body, formData, headers, onCancel);\n const responseBody = await getResponseBody(response);\n const responseHeader = getResponseHeader(response, options.responseHeader);\n\n const result: ApiResult = {\n url,\n ok: response.ok,\n status: response.status,\n statusText: response.statusText,\n body: responseHeader ?? responseBody,\n };\n\n catchErrorCodes(options, result);\n\n resolve(result.body);\n }\n } catch (error) {\n reject(error);\n }\n });\n};"; +},"usePartial":true,"useData":true}; + +var fetchSendRequest = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "export const sendRequest = async (\n config: OpenAPIConfig,\n options: ApiRequestOptions,\n url: string,\n body: any,\n formData: FormData | undefined,\n headers: Headers,\n onCancel: OnCancel\n): Promise => {\n const controller = new AbortController();\n\n const request: RequestInit = {\n headers,\n body: body ?? formData,\n method: options.method,\n signal: controller.signal,\n };\n\n if (config.WITH_CREDENTIALS) {\n request.credentials = config.CREDENTIALS;\n }\n\n onCancel(() => controller.abort());\n\n return await fetch(url, request);\n};"; +},"useData":true}; + +var functionBase64 = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const base64 = (str: string): string => { try { return btoa(str); } catch (err) { // @ts-ignore return\nBuffer.from(str).toString('base64'); } };"; +},"useData":true}; + +var functionCatchErrorCodes = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const catchErrorCodes = (options: ApiRequestOptions, result: ApiResult): void => {\n const errors: Record = {\n 400: 'Bad Request',\n 401: 'Unauthorized',\n 403: 'Forbidden',\n 404: 'Not Found',\n 500: 'Internal Server Error',\n 502: 'Bad Gateway',\n 503: 'Service Unavailable',\n ...options.errors,\n }\n\n const error = errors[result.status];\n if (error) {\n throw new ApiError(options, result, error);\n }\n\n if (!result.ok) {\n throw new ApiError(options, result, 'Generic Error');\n }\n};"; +},"useData":true}; + +var functionGetFormData = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getFormData = (options: ApiRequestOptions): FormData | undefined => { if (options.formData) { const formData = new\nFormData(); const process = (key: string, value: any) => { if (isString(value) || isBlob(value)) { formData.append(key,\nvalue); } else { formData.append(key, JSON.stringify(value)); } }; Object.entries(options.formData) .filter(([_, value])\n=> isDefined(value)) .forEach(([key, value]) => { if (Array.isArray(value)) { value.forEach(v => process(key, v)); }\nelse { process(key, value); } }); return formData; } return undefined; };"; +},"useData":true}; + +var functionGetQueryString = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getQueryString = (params: Record): string => {\n const qs: string[] = [];\n\n const append = (key: string, value: any) => {\n qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);\n };\n\n const process = (key: string, value: any) => {\n if (isDefined(value)) {\n if (Array.isArray(value)) {\n value.forEach(v => {\n process(key, v);\n });\n } else if (typeof value === 'object') {\n Object.entries(value).forEach(([k, v]) => {\n process(`${key}[${k}]`, v);\n });\n } else {\n append(key, value);\n }\n }\n };\n\n Object.entries(params).forEach(([key, value]) => {\n process(key, value);\n });\n\n if (qs.length > 0) {\n return `?${qs.join('&')}`;\n }\n\n return '';\n};"; +},"useData":true}; + +var functionGetUrl = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getUrl = (config: OpenAPIConfig, options: ApiRequestOptions): string => { const encoder = config.ENCODE_PATH ||\nencodeURI; const path = options.url .replace('{api-version}', config.VERSION) .replace(/{(.*?)}/g, (substring: string,\ngroup: string) => { if (options.path?.hasOwnProperty(group)) { return encoder(String(options.path[group])); } return\nsubstring; }); const url = `${config.BASE}${path}`; if (options.query) { return\n`${url}${getQueryString(options.query)}`; } return url; };"; +},"useData":true}; + +var functionIsBlob = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const isBlob = (value: any): value is Blob => { return ( typeof value === 'object' && typeof value.type === 'string' &&\ntypeof value.stream === 'function' && typeof value.arrayBuffer === 'function' && typeof value.constructor === 'function'\n&& typeof value.constructor.name === 'string' && /^(Blob|File)$/.test(value.constructor.name) &&\n/^(Blob|File)$/.test(value[Symbol.toStringTag]) ); };"; +},"useData":true}; + +var functionIsDefined = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const isDefined = (value: T | null | undefined): value is Exclude => {\n return value !== undefined && value !== null;\n};"; +},"useData":true}; + +var functionIsFormData = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const isFormData = (value: any): value is FormData => { return value instanceof FormData; };"; +},"useData":true}; + +var functionIsString = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const isString = (value: any): value is string => { return typeof value === 'string'; };"; +},"useData":true}; + +var functionIsStringWithValue = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const isStringWithValue = (value: any): value is string => { return isString(value) && value !== ''; };"; +},"useData":true}; + +var functionIsSuccess = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const isSuccess = (status: number): boolean => { return status >= 200 && status"; +},"useData":true}; + +var functionResolve = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "type Resolver = (options: ApiRequestOptions) => Promise;\n\nconst resolve = async (options: ApiRequestOptions, resolver?: T | Resolver): Promise => {\n if (typeof resolver === 'function') {\n return (resolver as Resolver)(options);\n }\n return resolver;\n};"; +},"useData":true}; + +var templateCoreHttpRequest = {"1":function(container,depth0,helpers,partials,data) { + return "import { Inject, Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport type { Observable } from 'rxjs';\n\nimport type { ApiRequestOptions } from './ApiRequestOptions';\nimport { BaseHttpRequest } from './BaseHttpRequest';\nimport type { OpenAPIConfig } from './OpenAPI';\nimport { OpenAPI } from './OpenAPI';\nimport { request as __request } from './request';\n"; +},"3":function(container,depth0,helpers,partials,data) { + return "import type { ApiRequestOptions } from './ApiRequestOptions';\nimport { BaseHttpRequest } from './BaseHttpRequest';\nimport type { CancelablePromise } from './CancelablePromise';\nimport type { OpenAPIConfig } from './OpenAPI';\nimport { request as __request } from './request';\n"; +},"5":function(container,depth0,helpers,partials,data) { + return "@Injectable()\n"; +},"7":function(container,depth0,helpers,partials,data) { + return " constructor(\n @Inject(OpenAPI)\n config: OpenAPIConfig,\n http: HttpClient,\n ) {\n super(config, http);\n }\n"; +},"9":function(container,depth0,helpers,partials,data) { + return " constructor(config: OpenAPIConfig) {\n super(config);\n }\n"; +},"11":function(container,depth0,helpers,partials,data) { + return " /**\n * Request method\n * @param options The request options from the service\n * @returns Observable\n * @throws ApiError\n */\n public override request(options: ApiRequestOptions): Observable {\n return __request(this.config, this.http, options);\n }\n"; +},"13":function(container,depth0,helpers,partials,data) { + return " /**\n * Request method\n * @param options The request options from the service\n * @returns CancelablePromise\n * @throws ApiError\n */\n public override request(options: ApiRequestOptions): CancelablePromise {\n return __request(this.config, options);\n }\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n" + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"angular",{"name":"equals","hash":{},"fn":container.program(1, data, 0),"inverse":container.program(3, data, 0),"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":19,"column":11}}})) != null ? stack1 : "") + + "\n" + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"angular",{"name":"equals","hash":{},"fn":container.program(5, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":21,"column":0},"end":{"line":23,"column":11}}})) != null ? stack1 : "") + + "export class " + + ((stack1 = (((helper = lookupProperty(helpers,"httpRequest") || container.strict(depth0, "httpRequest", {"start":{"line":24,"column":15},"end":{"line":24,"column":26}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"httpRequest","hash":{},"data":data,"loc":{"start":{"line":24,"column":13},"end":{"line":24,"column":28}}}) : helper))) != null ? stack1 : "") + + " extends BaseHttpRequest {\n\n" + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"angular",{"name":"equals","hash":{},"fn":container.program(7, data, 0),"inverse":container.program(9, data, 0),"data":data,"loc":{"start":{"line":26,"column":1},"end":{"line":38,"column":12}}})) != null ? stack1 : "") + + "\n" + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"angular",{"name":"equals","hash":{},"fn":container.program(11, data, 0),"inverse":container.program(13, data, 0),"data":data,"loc":{"start":{"line":40,"column":1},"end":{"line":60,"column":12}}})) != null ? stack1 : "") + + "}"; +},"usePartial":true,"useData":true}; + +var nodeGetHeaders = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getHeaders = async (config: OpenAPIConfig, options: ApiRequestOptions): Promise => {\n const token = await resolve(options, config.TOKEN);\n const username = await resolve(options, config.USERNAME);\n const password = await resolve(options, config.PASSWORD);\n const additionalHeaders = await resolve(options, config.HEADERS);\n\n const headers = Object.entries({\n Accept: 'application/json',\n ...additionalHeaders,\n ...options.headers,\n })\n .filter(([_, value]) => isDefined(value))\n .reduce((headers, [key, value]) => ({\n ...headers,\n [key]: String(value),\n }), {} as Record);\n\n if (isStringWithValue(token)) {\n headers['Authorization'] = `Bearer ${token}`;\n }\n\n if (isStringWithValue(username) && isStringWithValue(password)) {\n const credentials = base64(`${username}:${password}`);\n headers['Authorization'] = `Basic ${credentials}`;\n }\n\n if (options.body) {\n if (options.mediaType) {\n headers['Content-Type'] = options.mediaType;\n } else if (isBlob(options.body)) {\n headers['Content-Type'] = 'application/octet-stream';\n } else if (isString(options.body)) {\n headers['Content-Type'] = 'text/plain';\n } else if (!isFormData(options.body)) {\n headers['Content-Type'] = 'application/json';\n }\n }\n\n return new Headers(headers);\n};"; +},"useData":true}; + +var nodeGetRequestBody = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getRequestBody = (options: ApiRequestOptions): any => { if (options.body !== undefined) { if\n(options.mediaType?.includes('/json')) { return JSON.stringify(options.body) } else if (isString(options.body) ||\nisBlob(options.body) || isFormData(options.body)) { return options.body as any; } else { return\nJSON.stringify(options.body); } } return undefined; };"; +},"useData":true}; + +var nodeGetResponseBody = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getResponseBody = async (response: Response): Promise => {\n if (response.status !== 204) {\n try {\n const contentType = response.headers.get('Content-Type');\n if (contentType) {\n const jsonTypes = ['application/json', 'application/problem+json']\n const isJSON = jsonTypes.some(type => contentType.toLowerCase().startsWith(type));\n if (isJSON) {\n return await response.json();\n } else {\n return await response.text();\n }\n }\n } catch (error) {\n console.error(error);\n }\n }\n return undefined;\n};"; +},"useData":true}; + +var nodeGetResponseHeader = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getResponseHeader = (response: Response, responseHeader?: string): string | undefined => { if (responseHeader) {\nconst content = response.headers.get(responseHeader); if (isString(content)) { return content; } } return undefined; };"; +},"useData":true}; + +var nodeRequest = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\nimport FormData from 'form-data';\nimport fetch, { Headers } from 'node-fetch';\nimport type { RequestInit, Response } from 'node-fetch';\nimport type { AbortSignal } from 'node-fetch/externals';\n\nimport { ApiError } from './ApiError';\nimport type { ApiRequestOptions } from './ApiRequestOptions';\nimport type { ApiResult } from './ApiResult';\nimport { CancelablePromise } from './CancelablePromise';\nimport type { OnCancel } from './CancelablePromise';\nimport type { OpenAPIConfig } from './OpenAPI';\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isDefined"),depth0,{"name":"functions/isDefined","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isString"),depth0,{"name":"functions/isString","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isStringWithValue"),depth0,{"name":"functions/isStringWithValue","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isBlob"),depth0,{"name":"functions/isBlob","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isFormData"),depth0,{"name":"functions/isFormData","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/base64"),depth0,{"name":"functions/base64","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getQueryString"),depth0,{"name":"functions/getQueryString","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getUrl"),depth0,{"name":"functions/getUrl","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getFormData"),depth0,{"name":"functions/getFormData","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/resolve"),depth0,{"name":"functions/resolve","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"node/getHeaders"),depth0,{"name":"node/getHeaders","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"node/getRequestBody"),depth0,{"name":"node/getRequestBody","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"node/sendRequest"),depth0,{"name":"node/sendRequest","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"node/getResponseHeader"),depth0,{"name":"node/getResponseHeader","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"node/getResponseBody"),depth0,{"name":"node/getResponseBody","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/catchErrorCodes"),depth0,{"name":"functions/catchErrorCodes","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n/**\n * Request method\n * @param config The OpenAPI configuration object\n * @param options The request options from the service\n * @returns CancelablePromise\n * @throws ApiError\n */\nexport const request = (config: OpenAPIConfig, options: ApiRequestOptions): CancelablePromise => {\n return new CancelablePromise(async (resolve, reject, onCancel) => {\n try {\n const url = getUrl(config, options);\n const formData = getFormData(options);\n const body = getRequestBody(options);\n const headers = await getHeaders(config, options);\n\n if (!onCancel.isCancelled) {\n const response = await sendRequest(options, url, body, formData, headers, onCancel);\n const responseBody = await getResponseBody(response);\n const responseHeader = getResponseHeader(response, options.responseHeader);\n\n const result: ApiResult = {\n url,\n ok: response.ok,\n status: response.status,\n statusText: response.statusText,\n body: responseHeader ?? responseBody,\n };\n\n catchErrorCodes(options, result);\n\n resolve(result.body);\n }\n } catch (error) {\n reject(error);\n }\n });\n};"; +},"usePartial":true,"useData":true}; + +var nodeSendRequest = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "export const sendRequest = async (\n options: ApiRequestOptions,\n url: string,\n body: any,\n formData: FormData | undefined,\n headers: Headers,\n onCancel: OnCancel\n): Promise => {\n const controller = new AbortController();\n\n const request: RequestInit = {\n headers,\n method: options.method,\n body: body ?? formData,\n signal: controller.signal as AbortSignal,\n };\n\n onCancel(() => controller.abort());\n\n return await fetch(url, request);\n};"; +},"useData":true}; + +var templateCoreSettings = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\nimport type { ApiRequestOptions } from './ApiRequestOptions';\n\ntype Resolver = (options: ApiRequestOptions) => Promise;\ntype Headers = Record;\n\nexport type OpenAPIConfig = {\n BASE: string;\n VERSION: string;\n WITH_CREDENTIALS: boolean;\n CREDENTIALS: 'include' | 'omit' | 'same-origin';\n TOKEN?: string | Resolver;\n USERNAME?: string | Resolver;\n PASSWORD?: string | Resolver;\n HEADERS?: Headers | Resolver;\n ENCODE_PATH?: (path: string) => string;\n};\n\nexport const OpenAPI: OpenAPIConfig = {\n BASE: '" + + ((stack1 = (((helper = lookupProperty(helpers,"server") || alias1(depth0, "server", {"start":{"line":21,"column":11},"end":{"line":21,"column":17}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"server","hash":{},"data":data,"loc":{"start":{"line":21,"column":8},"end":{"line":21,"column":20}}}) : helper))) != null ? stack1 : "") + + "',\n VERSION: '" + + ((stack1 = (((helper = lookupProperty(helpers,"version") || alias1(depth0, "version", {"start":{"line":22,"column":14},"end":{"line":22,"column":21}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"version","hash":{},"data":data,"loc":{"start":{"line":22,"column":11},"end":{"line":22,"column":24}}}) : helper))) != null ? stack1 : "") + + "',\n WITH_CREDENTIALS: false,\n CREDENTIALS: 'include',\n TOKEN: undefined,\n USERNAME: undefined,\n PASSWORD: undefined,\n HEADERS: undefined,\n ENCODE_PATH: undefined,\n};"; +},"usePartial":true,"useData":true}; + +var templateCoreRequest = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"fetch/request"),depth0,{"name":"fetch/request","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"3":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"xhr/request"),depth0,{"name":"xhr/request","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"5":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"axios/request"),depth0,{"name":"axios/request","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"7":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"angular/request"),depth0,{"name":"angular/request","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"9":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"node/request"),depth0,{"name":"node/request","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"fetch",{"name":"equals","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":67}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"xhr",{"name":"equals","hash":{},"fn":container.program(3, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":2,"column":0},"end":{"line":2,"column":63}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"axios",{"name":"equals","hash":{},"fn":container.program(5, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":3,"column":67}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"angular",{"name":"equals","hash":{},"fn":container.program(7, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":4,"column":0},"end":{"line":4,"column":71}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"node",{"name":"equals","hash":{},"fn":container.program(9, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":5,"column":0},"end":{"line":5,"column":65}}})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var xhrGetHeaders = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getHeaders = async (config: OpenAPIConfig, options: ApiRequestOptions): Promise => {\n const token = await resolve(options, config.TOKEN);\n const username = await resolve(options, config.USERNAME);\n const password = await resolve(options, config.PASSWORD);\n const additionalHeaders = await resolve(options, config.HEADERS);\n\n const headers = Object.entries({\n Accept: 'application/json',\n ...additionalHeaders,\n ...options.headers,\n })\n .filter(([_, value]) => isDefined(value))\n .reduce((headers, [key, value]) => ({\n ...headers,\n [key]: String(value),\n }), {} as Record);\n\n if (isStringWithValue(token)) {\n headers['Authorization'] = `Bearer ${token}`;\n }\n\n if (isStringWithValue(username) && isStringWithValue(password)) {\n const credentials = base64(`${username}:${password}`);\n headers['Authorization'] = `Basic ${credentials}`;\n }\n\n if (options.body) {\n if (options.mediaType) {\n headers['Content-Type'] = options.mediaType;\n } else if (isBlob(options.body)) {\n headers['Content-Type'] = options.body.type || 'application/octet-stream';\n } else if (isString(options.body)) {\n headers['Content-Type'] = 'text/plain';\n } else if (!isFormData(options.body)) {\n headers['Content-Type'] = 'application/json';\n }\n }\n\n return new Headers(headers);\n};"; +},"useData":true}; + +var xhrGetRequestBody = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getRequestBody = (options: ApiRequestOptions): any => { if (options.body !== undefined) { if\n(options.mediaType?.includes('/json')) { return JSON.stringify(options.body) } else if (isString(options.body) ||\nisBlob(options.body) || isFormData(options.body)) { return options.body; } else { return JSON.stringify(options.body); }\n} return undefined; };"; +},"useData":true}; + +var xhrGetResponseBody = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getResponseBody = (xhr: XMLHttpRequest): any => { if (xhr.status !== 204) { try { const contentType =\nxhr.getResponseHeader('Content-Type'); if (contentType) { const jsonTypes = ['application/json',\n'application/problem+json'] const isJSON = jsonTypes.some(type => contentType.toLowerCase().startsWith(type)); if\n(isJSON) { return JSON.parse(xhr.responseText); } else { return xhr.responseText; } } } catch (error) {\nconsole.error(error); } } return undefined; };"; +},"useData":true}; + +var xhrGetResponseHeader = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "const getResponseHeader = (xhr: XMLHttpRequest, responseHeader?: string): string | undefined => { if (responseHeader) {\nconst content = xhr.getResponseHeader(responseHeader); if (isString(content)) { return content; } } return undefined; };"; +},"useData":true}; + +var xhrRequest = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\nimport { ApiError } from './ApiError';\nimport type { ApiRequestOptions } from './ApiRequestOptions';\nimport type { ApiResult } from './ApiResult';\nimport { CancelablePromise } from './CancelablePromise';\nimport type { OnCancel } from './CancelablePromise';\nimport type { OpenAPIConfig } from './OpenAPI';\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isDefined"),depth0,{"name":"functions/isDefined","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isString"),depth0,{"name":"functions/isString","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isStringWithValue"),depth0,{"name":"functions/isStringWithValue","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isBlob"),depth0,{"name":"functions/isBlob","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isFormData"),depth0,{"name":"functions/isFormData","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/isSuccess"),depth0,{"name":"functions/isSuccess","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/base64"),depth0,{"name":"functions/base64","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getQueryString"),depth0,{"name":"functions/getQueryString","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getUrl"),depth0,{"name":"functions/getUrl","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/getFormData"),depth0,{"name":"functions/getFormData","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/resolve"),depth0,{"name":"functions/resolve","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"fetch/getHeaders"),depth0,{"name":"fetch/getHeaders","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"xhr/getRequestBody"),depth0,{"name":"xhr/getRequestBody","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"xhr/sendRequest"),depth0,{"name":"xhr/sendRequest","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"xhr/getResponseHeader"),depth0,{"name":"xhr/getResponseHeader","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"xhr/getResponseBody"),depth0,{"name":"xhr/getResponseBody","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n" + + ((stack1 = container.invokePartial(lookupProperty(partials,"functions/catchErrorCodes"),depth0,{"name":"functions/catchErrorCodes","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n\n/**\n * Request method\n * @param config The OpenAPI configuration object\n * @param options The request options from the service\n * @returns CancelablePromise\n * @throws ApiError\n */\nexport const request = (config: OpenAPIConfig, options: ApiRequestOptions): CancelablePromise => {\n return new CancelablePromise(async (resolve, reject, onCancel) => {\n try {\n const url = getUrl(config, options);\n const formData = getFormData(options);\n const body = getRequestBody(options);\n const headers = await getHeaders(config, options);\n\n if (!onCancel.isCancelled) {\n const response = await sendRequest(config, options, url, body, formData, headers, onCancel);\n const responseBody = getResponseBody(response);\n const responseHeader = getResponseHeader(response, options.responseHeader);\n\n const result: ApiResult = {\n url,\n ok: isSuccess(response.status),\n status: response.status,\n statusText: response.statusText,\n body: responseHeader ?? responseBody,\n };\n\n catchErrorCodes(options, result);\n\n resolve(result.body);\n }\n } catch (error) {\n reject(error);\n }\n });\n};"; +},"usePartial":true,"useData":true}; + +var xhrSendRequest = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "export const sendRequest = async (\n config: OpenAPIConfig,\n options: ApiRequestOptions,\n url: string,\n body: any,\n formData: FormData | undefined,\n headers: Headers,\n onCancel: OnCancel\n): Promise => {\n const xhr = new XMLHttpRequest();\n xhr.open(options.method, url, true);\n xhr.withCredentials = config.WITH_CREDENTIALS;\n\n headers.forEach((value, key) => {\n xhr.setRequestHeader(key, value);\n });\n\n return new Promise((resolve, reject) => {\n xhr.onload = () => resolve(xhr);\n xhr.onabort = () => reject(new Error('Request aborted'));\n xhr.onerror = () => reject(new Error('Network error'));\n xhr.send(body ?? formData);\n\n onCancel(() => xhr.abort());\n });\n};"; +},"useData":true}; + +var templateExportModel = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "\n" + + ((stack1 = lookupProperty(helpers,"each").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"imports"),{"name":"each","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":5,"column":0},"end":{"line":7,"column":9}}})) != null ? stack1 : ""); +},"2":function(container,depth0,helpers,partials,data) { + var stack1, alias1=container.lambda; + + return "import type { " + + ((stack1 = alias1(depth0, depth0)) != null ? stack1 : "") + + " } from './" + + ((stack1 = alias1(depth0, depth0)) != null ? stack1 : "") + + "';\n"; +},"4":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"exportInterface"),depth0,{"name":"exportInterface","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"6":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"one-of",{"name":"equals","hash":{},"fn":container.program(7, data, 0),"inverse":container.program(9, data, 0),"data":data,"loc":{"start":{"line":12,"column":0},"end":{"line":26,"column":0}}})) != null ? stack1 : ""); +},"7":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"exportComposition"),depth0,{"name":"exportComposition","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"9":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"any-of",{"name":"equals","hash":{},"fn":container.program(7, data, 0),"inverse":container.program(10, data, 0),"data":data,"loc":{"start":{"line":14,"column":0},"end":{"line":26,"column":0}}})) != null ? stack1 : ""); +},"10":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"all-of",{"name":"equals","hash":{},"fn":container.program(7, data, 0),"inverse":container.program(11, data, 0),"data":data,"loc":{"start":{"line":16,"column":0},"end":{"line":26,"column":0}}})) != null ? stack1 : ""); +},"11":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"enum",{"name":"equals","hash":{},"fn":container.program(12, data, 0),"inverse":container.program(13, data, 0),"data":data,"loc":{"start":{"line":18,"column":0},"end":{"line":26,"column":0}}})) != null ? stack1 : ""); +},"12":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(lookupProperty(data,"root"),"useUnionTypes"),{"name":"if","hash":{},"fn":container.program(13, data, 0),"inverse":container.program(15, data, 0),"data":data,"loc":{"start":{"line":19,"column":0},"end":{"line":23,"column":7}}})) != null ? stack1 : ""); +},"13":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"exportType"),depth0,{"name":"exportType","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"15":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"exportEnum"),depth0,{"name":"exportEnum","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"imports"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":8,"column":7}}})) != null ? stack1 : "") + + "\n" + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(depth0,"export"),"interface",{"name":"equals","hash":{},"fn":container.program(4, data, 0),"inverse":container.program(6, data, 0),"data":data,"loc":{"start":{"line":10,"column":0},"end":{"line":26,"column":11}}})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var templateExportSchema = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\nexport const $" + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":3,"column":17},"end":{"line":3,"column":21}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"name","hash":{},"data":data,"loc":{"start":{"line":3,"column":14},"end":{"line":3,"column":24}}}) : helper))) != null ? stack1 : "") + + " = " + + ((stack1 = container.invokePartial(lookupProperty(partials,"schema"),depth0,{"name":"schema","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + " as const;"; +},"usePartial":true,"useData":true}; + +var templateExportService = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"each").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"imports"),{"name":"each","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":4,"column":0},"end":{"line":6,"column":9}}})) != null ? stack1 : ""); +},"2":function(container,depth0,helpers,partials,data) { + var stack1, alias1=container.lambda; + + return "import type { " + + ((stack1 = alias1(depth0, depth0)) != null ? stack1 : "") + + " } from 'sdk/src/api/models/Interfaces/GluonInterfaces/" + + ((stack1 = alias1(depth0, depth0)) != null ? stack1 : "") + + "';\n"; +},"4":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " /**\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"parameters"),{"name":"if","hash":{},"fn":container.program(5, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":17,"column":1},"end":{"line":25,"column":8}}})) != null ? stack1 : "") + + " */\n export interface " + + ((stack1 = (lookupProperty(helpers,"capitalizeFirst")||container.strict(depth0, "capitalizeFirst", {"start":{"line":27,"column":20},"end":{"line":27,"column":35}} )).call(alias1,lookupProperty(depth0,"name"),{"name":"capitalizeFirst","hash":{},"data":data,"loc":{"start":{"line":27,"column":18},"end":{"line":27,"column":42}}})) != null ? stack1 : "") + + "Params {\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias1,lookupProperty(depth0,"parameters"),{"name":"each","hash":{},"fn":container.program(11, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":28,"column":2},"end":{"line":38,"column":11}}})) != null ? stack1 : "") + + " }\n\n"; +},"5":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"each").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"parameters"),{"name":"each","hash":{},"fn":container.program(6, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":18,"column":1},"end":{"line":24,"column":10}}})) != null ? stack1 : ""); +},"6":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"name"),{"name":"if","hash":{},"fn":container.program(7, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":19,"column":2},"end":{"line":23,"column":9}}})) != null ? stack1 : ""); +},"7":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"notEquals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"name"),"userId",{"name":"notEquals","hash":{},"fn":container.program(8, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":20,"column":3},"end":{"line":22,"column":17}}})) != null ? stack1 : ""); +},"8":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " * @param { " + + ((stack1 = (((helper = lookupProperty(helpers,"type") || alias1(depth0, "type", {"start":{"line":21,"column":17},"end":{"line":21,"column":21}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"type","hash":{},"data":data,"loc":{"start":{"line":21,"column":14},"end":{"line":21,"column":24}}}) : helper))) != null ? stack1 : "") + + " } " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":21,"column":30},"end":{"line":21,"column":34}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":21,"column":27},"end":{"line":21,"column":37}}}) : helper))) != null ? stack1 : "") + + " " + + ((stack1 = lookupProperty(helpers,"if").call(alias2,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(9, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":21,"column":38},"end":{"line":21,"column":95}}})) != null ? stack1 : "") + + "\n"; +},"9":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"escapeComment").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeComment","hash":{},"data":data,"loc":{"start":{"line":21,"column":57},"end":{"line":21,"column":88}}})) != null ? stack1 : ""); +},"11":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"name"),{"name":"if","hash":{},"fn":container.program(12, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":29,"column":3},"end":{"line":37,"column":10}}})) != null ? stack1 : ""); +},"12":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"notEquals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"name"),"userId",{"name":"notEquals","hash":{},"fn":container.program(13, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":30,"column":4},"end":{"line":36,"column":18}}})) != null ? stack1 : ""); +},"13":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"isRequired"),{"name":"if","hash":{},"fn":container.program(14, data, 0),"inverse":container.program(16, data, 0),"data":data,"loc":{"start":{"line":31,"column":5},"end":{"line":35,"column":12}}})) != null ? stack1 : ""); +},"14":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":32,"column":9},"end":{"line":32,"column":13}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":32,"column":6},"end":{"line":32,"column":16}}}) : helper))) != null ? stack1 : "") + + ": " + + ((stack1 = (((helper = lookupProperty(helpers,"type") || alias1(depth0, "type", {"start":{"line":32,"column":20},"end":{"line":32,"column":24}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"type","hash":{},"data":data,"loc":{"start":{"line":32,"column":18},"end":{"line":32,"column":26}}}) : helper))) != null ? stack1 : "") + + ";\n"; +},"16":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":34,"column":9},"end":{"line":34,"column":13}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":34,"column":6},"end":{"line":34,"column":16}}}) : helper))) != null ? stack1 : "") + + "?: " + + ((stack1 = (((helper = lookupProperty(helpers,"type") || alias1(depth0, "type", {"start":{"line":34,"column":21},"end":{"line":34,"column":25}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"type","hash":{},"data":data,"loc":{"start":{"line":34,"column":19},"end":{"line":34,"column":27}}}) : helper))) != null ? stack1 : "") + + ";\n"; +},"18":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " /**\n * @param { " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":51,"column":16},"end":{"line":51,"column":20}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":51,"column":13},"end":{"line":51,"column":23}}}) : helper))) != null ? stack1 : "") + + "Params } object\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias2,lookupProperty(depth0,"results"),{"name":"each","hash":{},"fn":container.program(19, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":52,"column":1},"end":{"line":54,"column":10}}})) != null ? stack1 : "") + + " * @throws ApiError\n */\n\n public async " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":58,"column":17},"end":{"line":58,"column":21}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":58,"column":14},"end":{"line":58,"column":24}}}) : helper))) != null ? stack1 : "") + + "({\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias2,lookupProperty(depth0,"parameters"),{"name":"each","hash":{},"fn":container.program(21, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":59,"column":2},"end":{"line":69,"column":11}}})) != null ? stack1 : "") + + " } : " + + ((stack1 = (lookupProperty(helpers,"capitalizeFirst")||alias1(depth0, "capitalizeFirst", {"start":{"line":70,"column":8},"end":{"line":70,"column":23}} )).call(alias2,lookupProperty(depth0,"name"),{"name":"capitalizeFirst","hash":{},"data":data,"loc":{"start":{"line":70,"column":6},"end":{"line":70,"column":30}}})) != null ? stack1 : "") + + "Params ): Promise> {\n const result = await __request({\n method: '" + + ((stack1 = (((helper = lookupProperty(helpers,"method") || alias1(depth0, "method", {"start":{"line":72,"column":15},"end":{"line":72,"column":21}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"method","hash":{},"data":data,"loc":{"start":{"line":72,"column":12},"end":{"line":72,"column":24}}}) : helper))) != null ? stack1 : "") + + "',\n path: `" + + ((stack1 = (lookupProperty(helpers,"replace")||alias1(depth0, "replace", {"start":{"line":73,"column":13},"end":{"line":73,"column":20}} )).call(alias2,"userId","this.userId",{"name":"replace","hash":{},"fn":container.program(28, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":73,"column":10},"end":{"line":73,"column":100}}})) != null ? stack1 : "") + + "`,\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias2,lookupProperty(depth0,"parametersQuery"),{"name":"if","hash":{},"fn":container.program(31, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":74,"column":3},"end":{"line":80,"column":10}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias2,lookupProperty(depth0,"parametersBody"),{"name":"if","hash":{},"fn":container.program(35, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":81,"column":3},"end":{"line":85,"column":10}}})) != null ? stack1 : "") + + " });\n\n if (!result.ok) {\n catchError(result as BaseResult);\n }\n return result as BaseResult<" + + ((stack1 = container.invokePartial(lookupProperty(partials,"result"),depth0,{"name":"result","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ">;\n }\n\n"; +},"19":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " * @returns " + + ((stack1 = (((helper = lookupProperty(helpers,"type") || container.strict(depth0, "type", {"start":{"line":53,"column":16},"end":{"line":53,"column":20}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"type","hash":{},"data":data,"loc":{"start":{"line":53,"column":13},"end":{"line":53,"column":23}}}) : helper))) != null ? stack1 : "") + + " " + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(9, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":53,"column":24},"end":{"line":53,"column":81}}})) != null ? stack1 : "") + + "\n"; +},"21":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"name"),{"name":"if","hash":{},"fn":container.program(22, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":60,"column":3},"end":{"line":68,"column":10}}})) != null ? stack1 : ""); +},"22":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"notEquals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"name"),"userId",{"name":"notEquals","hash":{},"fn":container.program(23, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":61,"column":4},"end":{"line":67,"column":18}}})) != null ? stack1 : ""); +},"23":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"default"),{"name":"if","hash":{},"fn":container.program(24, data, 0),"inverse":container.program(26, data, 0),"data":data,"loc":{"start":{"line":62,"column":5},"end":{"line":66,"column":12}}})) != null ? stack1 : ""); +},"24":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":63,"column":9},"end":{"line":63,"column":13}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":63,"column":6},"end":{"line":63,"column":16}}}) : helper))) != null ? stack1 : "") + + " = " + + ((stack1 = (((helper = lookupProperty(helpers,"default") || alias1(depth0, "default", {"start":{"line":63,"column":22},"end":{"line":63,"column":29}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"default","hash":{},"data":data,"loc":{"start":{"line":63,"column":19},"end":{"line":63,"column":32}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"26":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":65,"column":9},"end":{"line":65,"column":13}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"name","hash":{},"data":data,"loc":{"start":{"line":65,"column":6},"end":{"line":65,"column":16}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"28":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = (lookupProperty(helpers,"replace")||container.strict(depth0, "replace", {"start":{"line":73,"column":48},"end":{"line":73,"column":55}} )).call(depth0 != null ? depth0 : (container.nullContext || {}),"{","${",{"name":"replace","hash":{},"fn":container.program(29, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":73,"column":45},"end":{"line":73,"column":88}}})) != null ? stack1 : ""); +},"29":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = (((helper = lookupProperty(helpers,"path") || container.strict(depth0, "path", {"start":{"line":73,"column":69},"end":{"line":73,"column":73}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"path","hash":{},"data":data,"loc":{"start":{"line":73,"column":66},"end":{"line":73,"column":76}}}) : helper))) != null ? stack1 : ""); +},"31":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " query: {\n" + + ((stack1 = lookupProperty(helpers,"each").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"parametersQuery"),{"name":"each","hash":{},"fn":container.program(32, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":76,"column":4},"end":{"line":78,"column":13}}})) != null ? stack1 : "") + + " },\n"; +},"32":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " '" + + ((stack1 = (((helper = lookupProperty(helpers,"prop") || alias1(depth0, "prop", {"start":{"line":77,"column":8},"end":{"line":77,"column":12}} ))),(typeof helper === "function" ? helper.call(alias2,{"name":"prop","hash":{},"data":data,"loc":{"start":{"line":77,"column":5},"end":{"line":77,"column":15}}}) : helper))) != null ? stack1 : "") + + "': " + + ((stack1 = (lookupProperty(helpers,"replace")||alias1(depth0, "replace", {"start":{"line":77,"column":21},"end":{"line":77,"column":28}} )).call(alias2,"userId","this.userId",{"name":"replace","hash":{},"fn":container.program(33, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":77,"column":18},"end":{"line":77,"column":75}}})) != null ? stack1 : "") + + ",\n"; +},"33":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":77,"column":56},"end":{"line":77,"column":60}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"name","hash":{},"data":data,"loc":{"start":{"line":77,"column":53},"end":{"line":77,"column":63}}}) : helper))) != null ? stack1 : ""); +},"35":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(lookupProperty(depth0,"parametersBody"),"in"),"body",{"name":"equals","hash":{},"fn":container.program(36, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":82,"column":3},"end":{"line":84,"column":14}}})) != null ? stack1 : ""); +},"36":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " body: " + + ((stack1 = container.lambda(container.strict(lookupProperty(depth0,"parametersBody"), "name", {"start":{"line":83,"column":12},"end":{"line":83,"column":31}} ), depth0)) != null ? stack1 : "") + + ",\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), alias2=container.strict, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"imports"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":7,"column":7}}})) != null ? stack1 : "") + + "\nimport { ErrorResult } from \"sdk/src/api/models/Interfaces/Repository/ErrorResult\";\nimport { BaseResult } from \"sdk/src/api/models/Interfaces/Repository/BaseResult\";\nimport { catchError } from 'sdk/src/api/core/ApiError';\nimport { request as __request } from 'sdk/src/api/core/request';\nimport { AuthHandler } from \"sdk/src/utilities/classes/AuthHandler\";\n\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias1,lookupProperty(depth0,"operations"),{"name":"each","hash":{},"fn":container.program(4, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":15,"column":0},"end":{"line":41,"column":9}}})) != null ? stack1 : "") + + "\nexport class " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias2(depth0, "name", {"start":{"line":43,"column":16},"end":{"line":43,"column":20}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":43,"column":13},"end":{"line":43,"column":23}}}) : helper))) != null ? stack1 : "") + + ((stack1 = container.lambda(alias2(lookupProperty(data,"root"), "postfix", {"start":{"line":43,"column":26},"end":{"line":43,"column":39}} ), depth0)) != null ? stack1 : "") + + " {\n private userId: string;\n constructor() {\n this.userId = AuthHandler.userId;\n }\n\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias1,lookupProperty(depth0,"operations"),{"name":"each","hash":{},"fn":container.program(18, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":49,"column":1},"end":{"line":94,"column":10}}})) != null ? stack1 : "") + + "}"; +},"usePartial":true,"useData":true}; + +var templateIndex = {"1":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "export { " + + ((stack1 = (((helper = lookupProperty(helpers,"clientName") || alias1(depth0, "clientName", {"start":{"line":4,"column":12},"end":{"line":4,"column":22}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"clientName","hash":{},"data":data,"loc":{"start":{"line":4,"column":9},"end":{"line":4,"column":25}}}) : helper))) != null ? stack1 : "") + + " } from './" + + ((stack1 = (((helper = lookupProperty(helpers,"clientName") || alias1(depth0, "clientName", {"start":{"line":4,"column":39},"end":{"line":4,"column":49}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"clientName","hash":{},"data":data,"loc":{"start":{"line":4,"column":36},"end":{"line":4,"column":52}}}) : helper))) != null ? stack1 : "") + + "';\n\n"; +},"3":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "export { ApiError } from './core/ApiError';\n" + + ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(lookupProperty(data,"root"),"exportClient"),{"name":"if","hash":{},"fn":container.program(4, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":9,"column":0},"end":{"line":11,"column":7}}})) != null ? stack1 : "") + + "export { OpenAPI } from './core/OpenAPI';\nexport { IBaseResult } from './core/IBaseResult';\nexport { IErrorResult } from './core/IErrorResult';\nexport { IParam } from './core/IParam';\nexport type { OpenAPIConfig } from './core/OpenAPI';\n"; +},"4":function(container,depth0,helpers,partials,data) { + return "export { BaseHttpRequest } from './core/BaseHttpRequest';\n"; +},"6":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"models"),{"name":"if","hash":{},"fn":container.program(7, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":20,"column":0},"end":{"line":33,"column":7}}})) != null ? stack1 : ""); +},"7":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "\n" + + ((stack1 = lookupProperty(helpers,"each").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"models"),{"name":"each","hash":{},"fn":container.program(8, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":22,"column":0},"end":{"line":32,"column":9}}})) != null ? stack1 : ""); +},"8":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(lookupProperty(data,"root"),"useUnionTypes"),{"name":"if","hash":{},"fn":container.program(9, data, 0),"inverse":container.program(12, data, 0),"data":data,"loc":{"start":{"line":23,"column":0},"end":{"line":31,"column":7}}})) != null ? stack1 : ""); +},"9":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "export type { " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":24,"column":17},"end":{"line":24,"column":21}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":24,"column":14},"end":{"line":24,"column":24}}}) : helper))) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias2,lookupProperty(lookupProperty(data,"root"),"postfixModels"),{"name":"if","hash":{},"fn":container.program(10, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":24,"column":24},"end":{"line":24,"column":97}}})) != null ? stack1 : "") + + " } from 'sdk/src/api/models/Interfaces/GluonInterfaces/" + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":24,"column":155},"end":{"line":24,"column":159}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":24,"column":152},"end":{"line":24,"column":162}}}) : helper))) != null ? stack1 : "") + + "';\n"; +},"10":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " as " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":24,"column":58},"end":{"line":24,"column":62}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"name","hash":{},"data":data,"loc":{"start":{"line":24,"column":55},"end":{"line":24,"column":65}}}) : helper))) != null ? stack1 : "") + + ((stack1 = container.lambda(alias1(lookupProperty(data,"root"), "postfixModels", {"start":{"line":24,"column":68},"end":{"line":24,"column":87}} ), depth0)) != null ? stack1 : ""); +},"12":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"enum"),{"name":"if","hash":{},"fn":container.program(13, data, 0),"inverse":container.program(15, data, 0),"data":data,"loc":{"start":{"line":25,"column":0},"end":{"line":31,"column":0}}})) != null ? stack1 : ""); +},"13":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "export { " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":26,"column":12},"end":{"line":26,"column":16}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":26,"column":9},"end":{"line":26,"column":19}}}) : helper))) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias2,lookupProperty(lookupProperty(data,"root"),"postfixModels"),{"name":"if","hash":{},"fn":container.program(10, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":26,"column":19},"end":{"line":26,"column":92}}})) != null ? stack1 : "") + + " } from 'sdk/src/api/models/Interfaces/GluonInterfaces/" + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":26,"column":150},"end":{"line":26,"column":154}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":26,"column":147},"end":{"line":26,"column":157}}}) : helper))) != null ? stack1 : "") + + "';\n"; +},"15":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"enums"),{"name":"if","hash":{},"fn":container.program(13, data, 0),"inverse":container.program(9, data, 0),"data":data,"loc":{"start":{"line":27,"column":0},"end":{"line":31,"column":0}}})) != null ? stack1 : ""); +},"17":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"models"),{"name":"if","hash":{},"fn":container.program(18, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":36,"column":0},"end":{"line":41,"column":7}}})) != null ? stack1 : ""); +},"18":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "\n" + + ((stack1 = lookupProperty(helpers,"each").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"models"),{"name":"each","hash":{},"fn":container.program(19, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":38,"column":0},"end":{"line":40,"column":9}}})) != null ? stack1 : ""); +},"19":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "export { $" + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":39,"column":13},"end":{"line":39,"column":17}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":39,"column":10},"end":{"line":39,"column":20}}}) : helper))) != null ? stack1 : "") + + " } from './schemas/$" + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":39,"column":43},"end":{"line":39,"column":47}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":39,"column":40},"end":{"line":39,"column":50}}}) : helper))) != null ? stack1 : "") + + "';\n"; +},"21":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"services"),{"name":"if","hash":{},"fn":container.program(22, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":44,"column":0},"end":{"line":49,"column":7}}})) != null ? stack1 : ""); +},"22":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "\n" + + ((stack1 = lookupProperty(helpers,"each").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"services"),{"name":"each","hash":{},"fn":container.program(23, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":46,"column":0},"end":{"line":48,"column":9}}})) != null ? stack1 : ""); +},"23":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", alias4=container.lambda, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "export { " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":47,"column":12},"end":{"line":47,"column":16}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":47,"column":9},"end":{"line":47,"column":19}}}) : helper))) != null ? stack1 : "") + + ((stack1 = alias4(alias1(lookupProperty(data,"root"), "postfixServices", {"start":{"line":47,"column":22},"end":{"line":47,"column":43}} ), depth0)) != null ? stack1 : "") + + " } from 'sdk/src/api/services/Gluon_services/" + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":47,"column":94},"end":{"line":47,"column":98}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":47,"column":91},"end":{"line":47,"column":101}}}) : helper))) != null ? stack1 : "") + + ((stack1 = alias4(alias1(lookupProperty(data,"root"), "postfixServices", {"start":{"line":47,"column":104},"end":{"line":47,"column":125}} ), depth0)) != null ? stack1 : "") + + "';\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"header"),depth0,{"name":"header","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + "\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(lookupProperty(data,"root"),"exportClient"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":6,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(lookupProperty(data,"root"),"exportCore"),{"name":"if","hash":{},"fn":container.program(3, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":7,"column":0},"end":{"line":18,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(lookupProperty(data,"root"),"exportModels"),{"name":"if","hash":{},"fn":container.program(6, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":19,"column":0},"end":{"line":34,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(lookupProperty(data,"root"),"exportSchemas"),{"name":"if","hash":{},"fn":container.program(17, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":35,"column":0},"end":{"line":42,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(lookupProperty(data,"root"),"exportServices"),{"name":"if","hash":{},"fn":container.program(21, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":43,"column":0},"end":{"line":50,"column":7}}})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var partialBase = {"1":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"fetch",{"name":"equals","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":2,"column":4},"end":{"line":2,"column":57}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"xhr",{"name":"equals","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":3,"column":4},"end":{"line":3,"column":55}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"axios",{"name":"equals","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":4,"column":4},"end":{"line":4,"column":57}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"angular",{"name":"equals","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":5,"column":4},"end":{"line":5,"column":59}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"equals").call(alias1,lookupProperty(lookupProperty(data,"root"),"httpClient"),"node",{"name":"equals","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":6,"column":4},"end":{"line":6,"column":56}}})) != null ? stack1 : ""); +},"2":function(container,depth0,helpers,partials,data) { + return "Blob"; +},"4":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = (((helper = lookupProperty(helpers,"base") || container.strict(depth0, "base", {"start":{"line":8,"column":7},"end":{"line":8,"column":11}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"base","hash":{},"data":data,"loc":{"start":{"line":8,"column":4},"end":{"line":8,"column":14}}}) : helper))) != null ? stack1 : ""); +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"base"),"binary",{"name":"equals","hash":{},"fn":container.program(1, data, 0),"inverse":container.program(4, data, 0),"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":9,"column":13}}})) != null ? stack1 : ""); +},"useData":true}; + +var partialExportComposition = {"1":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "/**\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":5,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"deprecated"),{"name":"if","hash":{},"fn":container.program(4, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":6,"column":0},"end":{"line":8,"column":7}}})) != null ? stack1 : "") + + " */\n"; +},"2":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " * " + + ((stack1 = lookupProperty(helpers,"escapeComment").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeComment","hash":{},"data":data,"loc":{"start":{"line":4,"column":3},"end":{"line":4,"column":34}}})) != null ? stack1 : "") + + "\n"; +},"4":function(container,depth0,helpers,partials,data) { + return " * @deprecated\n"; +},"6":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"unless").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(lookupProperty(data,"root"),"useUnionTypes"),{"name":"unless","hash":{},"fn":container.program(7, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":13,"column":0},"end":{"line":37,"column":11}}})) != null ? stack1 : ""); +},"7":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "\nexport namespace " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":15,"column":20},"end":{"line":15,"column":24}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":15,"column":17},"end":{"line":15,"column":27}}}) : helper))) != null ? stack1 : "") + + " {\n\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias1,lookupProperty(depth0,"enums"),{"name":"each","hash":{},"fn":container.program(8, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":17,"column":1},"end":{"line":34,"column":10}}})) != null ? stack1 : "") + + "\n}\n"; +},"8":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"ifdef").call(alias1,lookupProperty(depth0,"description"),lookupProperty(depth0,"deprecated"),{"name":"ifdef","hash":{},"fn":container.program(9, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":18,"column":1},"end":{"line":27,"column":11}}})) != null ? stack1 : "") + + " export enum " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":28,"column":16},"end":{"line":28,"column":20}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":28,"column":13},"end":{"line":28,"column":23}}}) : helper))) != null ? stack1 : "") + + " {\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias1,lookupProperty(depth0,"enum"),{"name":"each","hash":{},"fn":container.program(14, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":29,"column":2},"end":{"line":31,"column":11}}})) != null ? stack1 : "") + + " }\n\n"; +},"9":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " /**\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(10, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":20,"column":1},"end":{"line":22,"column":8}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"deprecated"),{"name":"if","hash":{},"fn":container.program(12, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":23,"column":1},"end":{"line":25,"column":8}}})) != null ? stack1 : "") + + " */\n"; +},"10":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " * " + + ((stack1 = lookupProperty(helpers,"escapeComment").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeComment","hash":{},"data":data,"loc":{"start":{"line":21,"column":4},"end":{"line":21,"column":35}}})) != null ? stack1 : "") + + "\n"; +},"12":function(container,depth0,helpers,partials,data) { + return " * @deprecated\n"; +},"14":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":30,"column":5},"end":{"line":30,"column":9}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":30,"column":2},"end":{"line":30,"column":12}}}) : helper))) != null ? stack1 : "") + + " = " + + ((stack1 = (((helper = lookupProperty(helpers,"value") || alias1(depth0, "value", {"start":{"line":30,"column":18},"end":{"line":30,"column":23}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"value","hash":{},"data":data,"loc":{"start":{"line":30,"column":15},"end":{"line":30,"column":26}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"ifdef").call(alias1,lookupProperty(depth0,"description"),lookupProperty(depth0,"deprecated"),{"name":"ifdef","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":10,"column":10}}})) != null ? stack1 : "") + + "export type " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":11,"column":15},"end":{"line":11,"column":19}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":11,"column":12},"end":{"line":11,"column":22}}}) : helper))) != null ? stack1 : "") + + " = " + + ((stack1 = container.invokePartial(lookupProperty(partials,"type"),depth0,{"name":"type","hash":{"parent":lookupProperty(depth0,"name")},"data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ";\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"enums"),{"name":"if","hash":{},"fn":container.program(6, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":12,"column":0},"end":{"line":38,"column":7}}})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var partialExportEnum = {"1":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " /**\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":3,"column":4},"end":{"line":6,"column":11}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"deprecated"),{"name":"if","hash":{},"fn":container.program(4, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":7,"column":4},"end":{"line":9,"column":11}}})) != null ? stack1 : "") + + " */\n"; +},"2":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " *\n " + + ((stack1 = lookupProperty(helpers,"escapeComment").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeComment","hash":{},"data":data,"loc":{"start":{"line":5,"column":8},"end":{"line":5,"column":39}}})) != null ? stack1 : "") + + "\n"; +},"4":function(container,depth0,helpers,partials,data) { + return " * @deprecated\n"; +},"6":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(7, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":16,"column":4},"end":{"line":20,"column":11}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"containsSpaces").call(alias1,lookupProperty(depth0,"name"),{"name":"containsSpaces","hash":{},"fn":container.program(9, data, 0),"inverse":container.program(11, data, 0),"data":data,"loc":{"start":{"line":21,"column":4},"end":{"line":28,"column":23}}})) != null ? stack1 : ""); +},"7":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " /** *\n " + + ((stack1 = lookupProperty(helpers,"escapeComment").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeComment","hash":{},"data":data,"loc":{"start":{"line":18,"column":8},"end":{"line":18,"column":39}}})) != null ? stack1 : "") + + "\n */\n"; +},"9":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " '" + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":22,"column":12},"end":{"line":22,"column":16}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":22,"column":9},"end":{"line":22,"column":19}}}) : helper))) != null ? stack1 : "") + + "' =\n " + + ((stack1 = (((helper = lookupProperty(helpers,"value") || alias1(depth0, "value", {"start":{"line":23,"column":11},"end":{"line":23,"column":16}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"value","hash":{},"data":data,"loc":{"start":{"line":23,"column":8},"end":{"line":23,"column":19}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"11":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":25,"column":11},"end":{"line":25,"column":15}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":25,"column":8},"end":{"line":25,"column":18}}}) : helper))) != null ? stack1 : "") + + "\n =\n " + + ((stack1 = (((helper = lookupProperty(helpers,"value") || alias1(depth0, "value", {"start":{"line":27,"column":11},"end":{"line":27,"column":16}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"value","hash":{},"data":data,"loc":{"start":{"line":27,"column":8},"end":{"line":27,"column":19}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"ifdef").call(alias1,lookupProperty(depth0,"description"),lookupProperty(depth0,"deprecated"),{"name":"ifdef","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":11,"column":10}}})) != null ? stack1 : "") + + "export enum\n" + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":13,"column":3},"end":{"line":13,"column":7}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":13,"column":0},"end":{"line":13,"column":10}}}) : helper))) != null ? stack1 : "") + + "\n{\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias1,lookupProperty(depth0,"enum"),{"name":"each","hash":{},"fn":container.program(6, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":15,"column":0},"end":{"line":29,"column":9}}})) != null ? stack1 : "") + + "}"; +},"useData":true}; + +var partialExportInterface = {"1":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "/**\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":5,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"deprecated"),{"name":"if","hash":{},"fn":container.program(4, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":6,"column":0},"end":{"line":8,"column":7}}})) != null ? stack1 : "") + + " */\n"; +},"2":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " * " + + ((stack1 = lookupProperty(helpers,"escapeComment").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeComment","hash":{},"data":data,"loc":{"start":{"line":4,"column":3},"end":{"line":4,"column":34}}})) != null ? stack1 : "") + + "\n"; +},"4":function(container,depth0,helpers,partials,data) { + return " * @deprecated\n"; +},"6":function(container,depth0,helpers,partials,data,blockParams,depths) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "export interface " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":12,"column":20},"end":{"line":12,"column":24}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":12,"column":17},"end":{"line":12,"column":27}}}) : helper))) != null ? stack1 : "") + + " {\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias1,lookupProperty(depth0,"properties"),{"name":"each","hash":{},"fn":container.program(7, data, 0, blockParams, depths),"inverse":container.noop,"data":data,"loc":{"start":{"line":13,"column":1},"end":{"line":25,"column":10}}})) != null ? stack1 : "") + + "};\n"; +},"7":function(container,depth0,helpers,partials,data,blockParams,depths) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"ifdef").call(alias1,lookupProperty(depth0,"description"),lookupProperty(depth0,"deprecated"),{"name":"ifdef","hash":{},"fn":container.program(8, data, 0, blockParams, depths),"inverse":container.noop,"data":data,"loc":{"start":{"line":14,"column":1},"end":{"line":23,"column":11}}})) != null ? stack1 : "") + + " " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":24,"column":4},"end":{"line":24,"column":8}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":24,"column":1},"end":{"line":24,"column":11}}}) : helper))) != null ? stack1 : "") + + ((stack1 = container.invokePartial(lookupProperty(partials,"isRequired"),depth0,{"name":"isRequired","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ": " + + ((stack1 = container.invokePartial(lookupProperty(partials,"type"),depth0,{"name":"type","hash":{"parent":lookupProperty(depths[1],"name")},"data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ";\n"; +},"8":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " /**\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(9, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":16,"column":1},"end":{"line":18,"column":8}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"deprecated"),{"name":"if","hash":{},"fn":container.program(11, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":19,"column":1},"end":{"line":21,"column":8}}})) != null ? stack1 : "") + + " */\n"; +},"9":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " * " + + ((stack1 = lookupProperty(helpers,"escapeComment").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeComment","hash":{},"data":data,"loc":{"start":{"line":17,"column":4},"end":{"line":17,"column":35}}})) != null ? stack1 : "") + + "\n"; +},"11":function(container,depth0,helpers,partials,data) { + return " * @deprecated\n"; +},"13":function(container,depth0,helpers,partials,data,blockParams,depths) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "export interface " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":28,"column":20},"end":{"line":28,"column":24}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":28,"column":17},"end":{"line":28,"column":27}}}) : helper))) != null ? stack1 : "") + + " {\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias1,lookupProperty(depth0,"properties"),{"name":"each","hash":{},"fn":container.program(14, data, 0, blockParams, depths),"inverse":container.noop,"data":data,"loc":{"start":{"line":29,"column":1},"end":{"line":41,"column":10}}})) != null ? stack1 : "") + + "};\n"; +},"14":function(container,depth0,helpers,partials,data,blockParams,depths) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"ifdef").call(alias1,lookupProperty(depth0,"description"),lookupProperty(depth0,"deprecated"),{"name":"ifdef","hash":{},"fn":container.program(8, data, 0, blockParams, depths),"inverse":container.noop,"data":data,"loc":{"start":{"line":30,"column":1},"end":{"line":39,"column":11}}})) != null ? stack1 : "") + + " readonly " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":40,"column":13},"end":{"line":40,"column":17}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":40,"column":10},"end":{"line":40,"column":20}}}) : helper))) != null ? stack1 : "") + + ((stack1 = container.invokePartial(lookupProperty(partials,"isRequired"),depth0,{"name":"isRequired","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ": " + + ((stack1 = container.invokePartial(lookupProperty(partials,"type"),depth0,{"name":"type","hash":{"parent":lookupProperty(depths[1],"name")},"data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ";\n"; +},"16":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"unless").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(lookupProperty(data,"root"),"useUnionTypes"),{"name":"unless","hash":{},"fn":container.program(17, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":45,"column":0},"end":{"line":61,"column":11}}})) != null ? stack1 : ""); +},"17":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "\nexport namespace " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":47,"column":20},"end":{"line":47,"column":24}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":47,"column":17},"end":{"line":47,"column":27}}}) : helper))) != null ? stack1 : "") + + " {\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias1,lookupProperty(depth0,"enums"),{"name":"each","hash":{},"fn":container.program(18, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":48,"column":1},"end":{"line":59,"column":10}}})) != null ? stack1 : "") + + "}\n"; +},"18":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(19, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":49,"column":1},"end":{"line":53,"column":8}}})) != null ? stack1 : "") + + " export enum " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":54,"column":16},"end":{"line":54,"column":20}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":54,"column":13},"end":{"line":54,"column":23}}}) : helper))) != null ? stack1 : "") + + " {\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias1,lookupProperty(depth0,"enum"),{"name":"each","hash":{},"fn":container.program(21, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":55,"column":2},"end":{"line":57,"column":11}}})) != null ? stack1 : "") + + " }\n"; +},"19":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " /**\n * " + + ((stack1 = lookupProperty(helpers,"escapeComment").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeComment","hash":{},"data":data,"loc":{"start":{"line":51,"column":4},"end":{"line":51,"column":35}}})) != null ? stack1 : "") + + "\n */\n"; +},"21":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=container.strict, alias2=depth0 != null ? depth0 : (container.nullContext || {}), alias3="function", lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || alias1(depth0, "name", {"start":{"line":56,"column":5},"end":{"line":56,"column":9}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":56,"column":2},"end":{"line":56,"column":12}}}) : helper))) != null ? stack1 : "") + + " = " + + ((stack1 = (((helper = lookupProperty(helpers,"value") || alias1(depth0, "value", {"start":{"line":56,"column":18},"end":{"line":56,"column":23}} ))),(typeof helper === alias3 ? helper.call(alias2,{"name":"value","hash":{},"data":data,"loc":{"start":{"line":56,"column":15},"end":{"line":56,"column":26}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data,blockParams,depths) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"ifdef").call(alias1,lookupProperty(depth0,"description"),lookupProperty(depth0,"deprecated"),{"name":"ifdef","hash":{},"fn":container.program(1, data, 0, blockParams, depths),"inverse":container.noop,"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":10,"column":10}}})) != null ? stack1 : "") + + ((stack1 = (lookupProperty(helpers,"if_eq")||container.strict(depth0, "if_eq", {"start":{"line":11,"column":3},"end":{"line":11,"column":8}} )).call(alias1,lookupProperty(depth0,"name"),{"name":"if_eq","hash":{},"fn":container.program(6, data, 0, blockParams, depths),"inverse":container.program(13, data, 0, blockParams, depths),"data":data,"loc":{"start":{"line":11,"column":0},"end":{"line":43,"column":10}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"enums"),{"name":"if","hash":{},"fn":container.program(16, data, 0, blockParams, depths),"inverse":container.noop,"data":data,"loc":{"start":{"line":44,"column":0},"end":{"line":62,"column":7}}})) != null ? stack1 : ""); +},"usePartial":true,"useData":true,"useDepths":true}; + +var partialExportType = {"1":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "/**\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":5,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"deprecated"),{"name":"if","hash":{},"fn":container.program(4, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":6,"column":0},"end":{"line":8,"column":7}}})) != null ? stack1 : "") + + " */\n"; +},"2":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " * " + + ((stack1 = lookupProperty(helpers,"escapeComment").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeComment","hash":{},"data":data,"loc":{"start":{"line":4,"column":3},"end":{"line":4,"column":34}}})) != null ? stack1 : "") + + "\n"; +},"4":function(container,depth0,helpers,partials,data) { + return " * @deprecated\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"ifdef").call(alias1,lookupProperty(depth0,"description"),lookupProperty(depth0,"deprecated"),{"name":"ifdef","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":10,"column":10}}})) != null ? stack1 : "") + + "export type " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":11,"column":15},"end":{"line":11,"column":19}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":11,"column":12},"end":{"line":11,"column":22}}}) : helper))) != null ? stack1 : "") + + " = " + + ((stack1 = container.invokePartial(lookupProperty(partials,"type"),depth0,{"name":"type","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ";"; +},"usePartial":true,"useData":true}; + +var partialHeader = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + return "/* istanbul ignore file */ /* tslint:disable */ /* eslint-disable */"; +},"useData":true}; + +var partialIsNullable = {"1":function(container,depth0,helpers,partials,data) { + return " | null"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"isNullable"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":32}}})) != null ? stack1 : ""); +},"useData":true}; + +var partialIsReadOnly = {"1":function(container,depth0,helpers,partials,data) { + return "readonly "; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"isReadOnly"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":34}}})) != null ? stack1 : ""); +},"useData":true}; + +var partialIsRequired = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"unless").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"isRequired"),{"name":"unless","hash":{},"fn":container.program(2, data, 0),"inverse":container.program(4, data, 0),"data":data,"loc":{"start":{"line":2,"column":4},"end":{"line":2,"column":69}}})) != null ? stack1 : ""); +},"2":function(container,depth0,helpers,partials,data) { + return "?"; +},"4":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"default"),{"name":"if","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":2,"column":35},"end":{"line":2,"column":58}}})) != null ? stack1 : ""); +},"6":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"unless").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"isRequired"),{"name":"unless","hash":{},"fn":container.program(7, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":4,"column":4},"end":{"line":4,"column":68}}})) != null ? stack1 : ""); +},"7":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"unless").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"default"),{"name":"unless","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":4,"column":26},"end":{"line":4,"column":57}}})) != null ? stack1 : ""); +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(lookupProperty(data,"root"),"useOptions"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.program(6, data, 0),"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":5,"column":9}}})) != null ? stack1 : ""); +},"useData":true}; + +var partialParameters = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(lookupProperty(data,"root"),"useOptions"),{"name":"if","hash":{},"fn":container.program(2, data, 0),"inverse":container.program(12, data, 0),"data":data,"loc":{"start":{"line":2,"column":0},"end":{"line":27,"column":7}}})) != null ? stack1 : ""); +},"2":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "{\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias1,lookupProperty(depth0,"parameters"),{"name":"each","hash":{},"fn":container.program(3, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":4,"column":0},"end":{"line":6,"column":9}}})) != null ? stack1 : "") + + "}: {\n" + + ((stack1 = lookupProperty(helpers,"each").call(alias1,lookupProperty(depth0,"parameters"),{"name":"each","hash":{},"fn":container.program(6, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":8,"column":0},"end":{"line":20,"column":9}}})) != null ? stack1 : "") + + "}"; +},"3":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":5,"column":3},"end":{"line":5,"column":7}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":5,"column":0},"end":{"line":5,"column":10}}}) : helper))) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"default"),{"name":"if","hash":{},"fn":container.program(4, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":5,"column":10},"end":{"line":5,"column":48}}})) != null ? stack1 : "") + + ",\n"; +},"4":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " = " + + ((stack1 = (((helper = lookupProperty(helpers,"default") || container.strict(depth0, "default", {"start":{"line":5,"column":31},"end":{"line":5,"column":38}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"default","hash":{},"data":data,"loc":{"start":{"line":5,"column":28},"end":{"line":5,"column":41}}}) : helper))) != null ? stack1 : ""); +},"6":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"ifdef").call(alias1,lookupProperty(depth0,"description"),lookupProperty(depth0,"deprecated"),{"name":"ifdef","hash":{},"fn":container.program(7, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":9,"column":0},"end":{"line":18,"column":10}}})) != null ? stack1 : "") + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":19,"column":3},"end":{"line":19,"column":7}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":19,"column":0},"end":{"line":19,"column":10}}}) : helper))) != null ? stack1 : "") + + ((stack1 = container.invokePartial(lookupProperty(partials,"isRequired"),depth0,{"name":"isRequired","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ": " + + ((stack1 = container.invokePartial(lookupProperty(partials,"type"),depth0,{"name":"type","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ",\n"; +},"7":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "/**\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(8, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":11,"column":0},"end":{"line":13,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"deprecated"),{"name":"if","hash":{},"fn":container.program(10, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":14,"column":0},"end":{"line":16,"column":7}}})) != null ? stack1 : "") + + " */\n"; +},"8":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " * " + + ((stack1 = lookupProperty(helpers,"escapeComment").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeComment","hash":{},"data":data,"loc":{"start":{"line":12,"column":3},"end":{"line":12,"column":34}}})) != null ? stack1 : "") + + "\n"; +},"10":function(container,depth0,helpers,partials,data) { + return " * @deprecated\n"; +},"12":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "\n" + + ((stack1 = lookupProperty(helpers,"each").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"parameters"),{"name":"each","hash":{},"fn":container.program(13, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":24,"column":0},"end":{"line":26,"column":9}}})) != null ? stack1 : ""); +},"13":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":25,"column":3},"end":{"line":25,"column":7}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"name","hash":{},"data":data,"loc":{"start":{"line":25,"column":0},"end":{"line":25,"column":10}}}) : helper))) != null ? stack1 : "") + + ((stack1 = container.invokePartial(lookupProperty(partials,"isRequired"),depth0,{"name":"isRequired","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ": " + + ((stack1 = container.invokePartial(lookupProperty(partials,"type"),depth0,{"name":"type","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"default"),{"name":"if","hash":{},"fn":container.program(4, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":25,"column":36},"end":{"line":25,"column":74}}})) != null ? stack1 : "") + + ",\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"parameters"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":28,"column":7}}})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var partialResult = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"each").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"results"),{"name":"each","hash":{},"fn":container.program(2, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":2,"column":0},"end":{"line":2,"column":66}}})) != null ? stack1 : ""); +},"2":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"type"),depth0,{"name":"type","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"unless").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(data,"last"),{"name":"unless","hash":{},"fn":container.program(3, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":2,"column":26},"end":{"line":2,"column":57}}})) != null ? stack1 : ""); +},"3":function(container,depth0,helpers,partials,data) { + return " | "; +},"5":function(container,depth0,helpers,partials,data) { + return "void"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"results"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.program(5, data, 0),"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":5,"column":9}}})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var partialSchema = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"schemaInterface"),depth0,{"name":"schemaInterface","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"3":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"enum",{"name":"equals","hash":{},"fn":container.program(4, data, 0),"inverse":container.program(6, data, 0),"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":17,"column":0}}})) != null ? stack1 : ""); +},"4":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"schemaEnum"),depth0,{"name":"schemaEnum","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"6":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"array",{"name":"equals","hash":{},"fn":container.program(7, data, 0),"inverse":container.program(9, data, 0),"data":data,"loc":{"start":{"line":5,"column":0},"end":{"line":17,"column":0}}})) != null ? stack1 : ""); +},"7":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"schemaArray"),depth0,{"name":"schemaArray","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"9":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"dictionary",{"name":"equals","hash":{},"fn":container.program(10, data, 0),"inverse":container.program(12, data, 0),"data":data,"loc":{"start":{"line":7,"column":0},"end":{"line":17,"column":0}}})) != null ? stack1 : ""); +},"10":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"schemaDictionary"),depth0,{"name":"schemaDictionary","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"12":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"any-of",{"name":"equals","hash":{},"fn":container.program(13, data, 0),"inverse":container.program(15, data, 0),"data":data,"loc":{"start":{"line":9,"column":0},"end":{"line":17,"column":0}}})) != null ? stack1 : ""); +},"13":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"schemaComposition"),depth0,{"name":"schemaComposition","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"15":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"all-of",{"name":"equals","hash":{},"fn":container.program(13, data, 0),"inverse":container.program(16, data, 0),"data":data,"loc":{"start":{"line":11,"column":0},"end":{"line":17,"column":0}}})) != null ? stack1 : ""); +},"16":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"one-of",{"name":"equals","hash":{},"fn":container.program(13, data, 0),"inverse":container.program(17, data, 0),"data":data,"loc":{"start":{"line":13,"column":0},"end":{"line":17,"column":0}}})) != null ? stack1 : ""); +},"17":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"schemaGeneric"),depth0,{"name":"schemaGeneric","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"interface",{"name":"equals","hash":{},"fn":container.program(1, data, 0),"inverse":container.program(3, data, 0),"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":17,"column":11}}})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var partialSchemaArray = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " contains: " + + ((stack1 = container.invokePartial(lookupProperty(partials,"schema"),lookupProperty(depth0,"link"),{"name":"schema","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ",\n"; +},"3":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " contains: {\n type: '" + + ((stack1 = (((helper = lookupProperty(helpers,"base") || container.strict(depth0, "base", {"start":{"line":7,"column":12},"end":{"line":7,"column":16}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"base","hash":{},"data":data,"loc":{"start":{"line":7,"column":9},"end":{"line":7,"column":19}}}) : helper))) != null ? stack1 : "") + + "',\n },\n"; +},"5":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isReadOnly: " + + ((stack1 = (((helper = lookupProperty(helpers,"isReadOnly") || container.strict(depth0, "isReadOnly", {"start":{"line":11,"column":16},"end":{"line":11,"column":26}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isReadOnly","hash":{},"data":data,"loc":{"start":{"line":11,"column":13},"end":{"line":11,"column":29}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"7":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isRequired: " + + ((stack1 = (((helper = lookupProperty(helpers,"isRequired") || container.strict(depth0, "isRequired", {"start":{"line":14,"column":16},"end":{"line":14,"column":26}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isRequired","hash":{},"data":data,"loc":{"start":{"line":14,"column":13},"end":{"line":14,"column":29}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"9":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isNullable: " + + ((stack1 = (((helper = lookupProperty(helpers,"isNullable") || container.strict(depth0, "isNullable", {"start":{"line":17,"column":16},"end":{"line":17,"column":26}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isNullable","hash":{},"data":data,"loc":{"start":{"line":17,"column":13},"end":{"line":17,"column":29}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "{\n type: 'array',\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"link"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.program(3, data, 0),"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":9,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isReadOnly"),{"name":"if","hash":{},"fn":container.program(5, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":10,"column":0},"end":{"line":12,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isRequired"),{"name":"if","hash":{},"fn":container.program(7, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":13,"column":0},"end":{"line":15,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isNullable"),{"name":"if","hash":{},"fn":container.program(9, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":16,"column":0},"end":{"line":18,"column":7}}})) != null ? stack1 : "") + + "}"; +},"usePartial":true,"useData":true}; + +var partialSchemaComposition = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " description: `" + + ((stack1 = lookupProperty(helpers,"escapeDescription").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeDescription","hash":{},"data":data,"loc":{"start":{"line":4,"column":15},"end":{"line":4,"column":50}}})) != null ? stack1 : "") + + "`,\n"; +},"3":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"schema"),depth0,{"name":"schema","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"unless").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(data,"last"),{"name":"unless","hash":{},"fn":container.program(4, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":6,"column":43},"end":{"line":6,"column":73}}})) != null ? stack1 : ""); +},"4":function(container,depth0,helpers,partials,data) { + return ", "; +},"6":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isReadOnly: " + + ((stack1 = (((helper = lookupProperty(helpers,"isReadOnly") || container.strict(depth0, "isReadOnly", {"start":{"line":8,"column":16},"end":{"line":8,"column":26}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isReadOnly","hash":{},"data":data,"loc":{"start":{"line":8,"column":13},"end":{"line":8,"column":29}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"8":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isRequired: " + + ((stack1 = (((helper = lookupProperty(helpers,"isRequired") || container.strict(depth0, "isRequired", {"start":{"line":11,"column":16},"end":{"line":11,"column":26}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isRequired","hash":{},"data":data,"loc":{"start":{"line":11,"column":13},"end":{"line":11,"column":29}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"10":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isNullable: " + + ((stack1 = (((helper = lookupProperty(helpers,"isNullable") || container.strict(depth0, "isNullable", {"start":{"line":14,"column":16},"end":{"line":14,"column":26}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isNullable","hash":{},"data":data,"loc":{"start":{"line":14,"column":13},"end":{"line":14,"column":29}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, helper, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "{\n type: '" + + ((stack1 = (((helper = lookupProperty(helpers,"export") || container.strict(depth0, "export", {"start":{"line":2,"column":10},"end":{"line":2,"column":16}} ))),(typeof helper === "function" ? helper.call(alias1,{"name":"export","hash":{},"data":data,"loc":{"start":{"line":2,"column":8},"end":{"line":2,"column":18}}}) : helper))) != null ? stack1 : "") + + "',\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":5,"column":7}}})) != null ? stack1 : "") + + " contains: [" + + ((stack1 = lookupProperty(helpers,"each").call(alias1,lookupProperty(depth0,"properties"),{"name":"each","hash":{},"fn":container.program(3, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":6,"column":12},"end":{"line":6,"column":82}}})) != null ? stack1 : "") + + "],\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isReadOnly"),{"name":"if","hash":{},"fn":container.program(6, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":7,"column":0},"end":{"line":9,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isRequired"),{"name":"if","hash":{},"fn":container.program(8, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":10,"column":0},"end":{"line":12,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isNullable"),{"name":"if","hash":{},"fn":container.program(10, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":13,"column":0},"end":{"line":15,"column":7}}})) != null ? stack1 : "") + + "}"; +},"usePartial":true,"useData":true}; + +var partialSchemaDictionary = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " contains: " + + ((stack1 = container.invokePartial(lookupProperty(partials,"schema"),lookupProperty(depth0,"link"),{"name":"schema","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ",\n"; +},"3":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " contains: {\n type: '" + + ((stack1 = (((helper = lookupProperty(helpers,"base") || container.strict(depth0, "base", {"start":{"line":7,"column":12},"end":{"line":7,"column":16}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"base","hash":{},"data":data,"loc":{"start":{"line":7,"column":9},"end":{"line":7,"column":19}}}) : helper))) != null ? stack1 : "") + + "',\n },\n"; +},"5":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isReadOnly: " + + ((stack1 = (((helper = lookupProperty(helpers,"isReadOnly") || container.strict(depth0, "isReadOnly", {"start":{"line":11,"column":16},"end":{"line":11,"column":26}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isReadOnly","hash":{},"data":data,"loc":{"start":{"line":11,"column":13},"end":{"line":11,"column":29}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"7":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isRequired: " + + ((stack1 = (((helper = lookupProperty(helpers,"isRequired") || container.strict(depth0, "isRequired", {"start":{"line":14,"column":16},"end":{"line":14,"column":26}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isRequired","hash":{},"data":data,"loc":{"start":{"line":14,"column":13},"end":{"line":14,"column":29}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"9":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isNullable: " + + ((stack1 = (((helper = lookupProperty(helpers,"isNullable") || container.strict(depth0, "isNullable", {"start":{"line":17,"column":16},"end":{"line":17,"column":26}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isNullable","hash":{},"data":data,"loc":{"start":{"line":17,"column":13},"end":{"line":17,"column":29}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "{\n type: 'dictionary',\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"link"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.program(3, data, 0),"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":9,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isReadOnly"),{"name":"if","hash":{},"fn":container.program(5, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":10,"column":0},"end":{"line":12,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isRequired"),{"name":"if","hash":{},"fn":container.program(7, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":13,"column":0},"end":{"line":15,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isNullable"),{"name":"if","hash":{},"fn":container.program(9, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":16,"column":0},"end":{"line":18,"column":7}}})) != null ? stack1 : "") + + "}"; +},"usePartial":true,"useData":true}; + +var partialSchemaEnum = {"1":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isReadOnly:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"isReadOnly") || container.strict(depth0, "isReadOnly", {"start":{"line":4,"column":7},"end":{"line":4,"column":17}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isReadOnly","hash":{},"data":data,"loc":{"start":{"line":4,"column":4},"end":{"line":4,"column":20}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"3":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isRequired:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"isRequired") || container.strict(depth0, "isRequired", {"start":{"line":8,"column":7},"end":{"line":8,"column":17}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isRequired","hash":{},"data":data,"loc":{"start":{"line":8,"column":4},"end":{"line":8,"column":20}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"5":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isNullable:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"isNullable") || container.strict(depth0, "isNullable", {"start":{"line":12,"column":7},"end":{"line":12,"column":17}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isNullable","hash":{},"data":data,"loc":{"start":{"line":12,"column":4},"end":{"line":12,"column":20}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "{ type: 'Enum',\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isReadOnly"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":2,"column":0},"end":{"line":5,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isRequired"),{"name":"if","hash":{},"fn":container.program(3, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":6,"column":0},"end":{"line":9,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isNullable"),{"name":"if","hash":{},"fn":container.program(5, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":10,"column":0},"end":{"line":13,"column":7}}})) != null ? stack1 : "") + + "}"; +},"useData":true}; + +var partialSchemaGeneric = {"1":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " type: '" + + ((stack1 = (((helper = lookupProperty(helpers,"type") || container.strict(depth0, "type", {"start":{"line":3,"column":14},"end":{"line":3,"column":18}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"type","hash":{},"data":data,"loc":{"start":{"line":3,"column":11},"end":{"line":3,"column":21}}}) : helper))) != null ? stack1 : "") + + "',\n"; +},"3":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " description: `" + + ((stack1 = lookupProperty(helpers,"escapeDescription").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeDescription","hash":{},"data":data,"loc":{"start":{"line":6,"column":18},"end":{"line":6,"column":53}}})) != null ? stack1 : "") + + "`,\n"; +},"5":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isReadOnly:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"isReadOnly") || container.strict(depth0, "isReadOnly", {"start":{"line":10,"column":7},"end":{"line":10,"column":17}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isReadOnly","hash":{},"data":data,"loc":{"start":{"line":10,"column":4},"end":{"line":10,"column":20}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"7":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isRequired:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"isRequired") || container.strict(depth0, "isRequired", {"start":{"line":14,"column":7},"end":{"line":14,"column":17}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isRequired","hash":{},"data":data,"loc":{"start":{"line":14,"column":4},"end":{"line":14,"column":20}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"9":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isNullable:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"isNullable") || container.strict(depth0, "isNullable", {"start":{"line":18,"column":7},"end":{"line":18,"column":17}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isNullable","hash":{},"data":data,"loc":{"start":{"line":18,"column":4},"end":{"line":18,"column":20}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"11":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " format: '" + + ((stack1 = (((helper = lookupProperty(helpers,"format") || container.strict(depth0, "format", {"start":{"line":21,"column":16},"end":{"line":21,"column":22}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"format","hash":{},"data":data,"loc":{"start":{"line":21,"column":13},"end":{"line":21,"column":25}}}) : helper))) != null ? stack1 : "") + + "',\n"; +},"13":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " maximum:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"maximum") || container.strict(depth0, "maximum", {"start":{"line":25,"column":7},"end":{"line":25,"column":14}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"maximum","hash":{},"data":data,"loc":{"start":{"line":25,"column":4},"end":{"line":25,"column":17}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"15":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " exclusiveMaximum:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"exclusiveMaximum") || container.strict(depth0, "exclusiveMaximum", {"start":{"line":29,"column":7},"end":{"line":29,"column":23}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"exclusiveMaximum","hash":{},"data":data,"loc":{"start":{"line":29,"column":4},"end":{"line":29,"column":26}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"17":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " minimum:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"minimum") || container.strict(depth0, "minimum", {"start":{"line":33,"column":7},"end":{"line":33,"column":14}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"minimum","hash":{},"data":data,"loc":{"start":{"line":33,"column":4},"end":{"line":33,"column":17}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"19":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " exclusiveMinimum:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"exclusiveMinimum") || container.strict(depth0, "exclusiveMinimum", {"start":{"line":37,"column":7},"end":{"line":37,"column":23}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"exclusiveMinimum","hash":{},"data":data,"loc":{"start":{"line":37,"column":4},"end":{"line":37,"column":26}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"21":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " multipleOf:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"multipleOf") || container.strict(depth0, "multipleOf", {"start":{"line":41,"column":7},"end":{"line":41,"column":17}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"multipleOf","hash":{},"data":data,"loc":{"start":{"line":41,"column":4},"end":{"line":41,"column":20}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"23":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " maxLength:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"maxLength") || container.strict(depth0, "maxLength", {"start":{"line":45,"column":7},"end":{"line":45,"column":16}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"maxLength","hash":{},"data":data,"loc":{"start":{"line":45,"column":4},"end":{"line":45,"column":19}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"25":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " minLength:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"minLength") || container.strict(depth0, "minLength", {"start":{"line":49,"column":7},"end":{"line":49,"column":16}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"minLength","hash":{},"data":data,"loc":{"start":{"line":49,"column":4},"end":{"line":49,"column":19}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"27":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " pattern: '" + + ((stack1 = (((helper = lookupProperty(helpers,"pattern") || container.strict(depth0, "pattern", {"start":{"line":52,"column":17},"end":{"line":52,"column":24}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"pattern","hash":{},"data":data,"loc":{"start":{"line":52,"column":14},"end":{"line":52,"column":27}}}) : helper))) != null ? stack1 : "") + + "',\n"; +},"29":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " maxItems:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"maxItems") || container.strict(depth0, "maxItems", {"start":{"line":56,"column":7},"end":{"line":56,"column":15}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"maxItems","hash":{},"data":data,"loc":{"start":{"line":56,"column":4},"end":{"line":56,"column":18}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"31":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " minItems:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"minItems") || container.strict(depth0, "minItems", {"start":{"line":60,"column":7},"end":{"line":60,"column":15}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"minItems","hash":{},"data":data,"loc":{"start":{"line":60,"column":4},"end":{"line":60,"column":18}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"33":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " uniqueItems:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"uniqueItems") || container.strict(depth0, "uniqueItems", {"start":{"line":64,"column":7},"end":{"line":64,"column":18}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"uniqueItems","hash":{},"data":data,"loc":{"start":{"line":64,"column":4},"end":{"line":64,"column":21}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"35":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " maxProperties:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"maxProperties") || container.strict(depth0, "maxProperties", {"start":{"line":68,"column":7},"end":{"line":68,"column":20}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"maxProperties","hash":{},"data":data,"loc":{"start":{"line":68,"column":4},"end":{"line":68,"column":23}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"37":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " minProperties:\n " + + ((stack1 = (((helper = lookupProperty(helpers,"minProperties") || container.strict(depth0, "minProperties", {"start":{"line":72,"column":7},"end":{"line":72,"column":20}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"minProperties","hash":{},"data":data,"loc":{"start":{"line":72,"column":4},"end":{"line":72,"column":23}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "{\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"type"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":2,"column":0},"end":{"line":4,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(3, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":5,"column":0},"end":{"line":7,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isReadOnly"),{"name":"if","hash":{},"fn":container.program(5, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":8,"column":0},"end":{"line":11,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isRequired"),{"name":"if","hash":{},"fn":container.program(7, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":12,"column":0},"end":{"line":15,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isNullable"),{"name":"if","hash":{},"fn":container.program(9, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":16,"column":0},"end":{"line":19,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"format"),{"name":"if","hash":{},"fn":container.program(11, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":20,"column":0},"end":{"line":22,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"maximum"),{"name":"if","hash":{},"fn":container.program(13, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":23,"column":0},"end":{"line":26,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"exclusiveMaximum"),{"name":"if","hash":{},"fn":container.program(15, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":27,"column":0},"end":{"line":30,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"minimum"),{"name":"if","hash":{},"fn":container.program(17, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":31,"column":0},"end":{"line":34,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"exclusiveMinimum"),{"name":"if","hash":{},"fn":container.program(19, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":35,"column":0},"end":{"line":38,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"multipleOf"),{"name":"if","hash":{},"fn":container.program(21, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":39,"column":0},"end":{"line":42,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"maxLength"),{"name":"if","hash":{},"fn":container.program(23, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":43,"column":0},"end":{"line":46,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"minLength"),{"name":"if","hash":{},"fn":container.program(25, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":47,"column":0},"end":{"line":50,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"pattern"),{"name":"if","hash":{},"fn":container.program(27, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":51,"column":0},"end":{"line":53,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"maxItems"),{"name":"if","hash":{},"fn":container.program(29, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":54,"column":0},"end":{"line":57,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"minItems"),{"name":"if","hash":{},"fn":container.program(31, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":58,"column":0},"end":{"line":61,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"uniqueItems"),{"name":"if","hash":{},"fn":container.program(33, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":62,"column":0},"end":{"line":65,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"maxProperties"),{"name":"if","hash":{},"fn":container.program(35, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":66,"column":0},"end":{"line":69,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"minProperties"),{"name":"if","hash":{},"fn":container.program(37, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":70,"column":0},"end":{"line":73,"column":7}}})) != null ? stack1 : "") + + "}"; +},"useData":true}; + +var partialSchemaInterface = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " description: `" + + ((stack1 = lookupProperty(helpers,"escapeDescription").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeDescription","hash":{},"data":data,"loc":{"start":{"line":3,"column":15},"end":{"line":3,"column":50}}})) != null ? stack1 : "") + + "`,\n"; +},"3":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"each").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"properties"),{"name":"each","hash":{},"fn":container.program(4, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":7,"column":1},"end":{"line":9,"column":10}}})) != null ? stack1 : ""); +},"4":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " " + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":8,"column":5},"end":{"line":8,"column":9}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"name","hash":{},"data":data,"loc":{"start":{"line":8,"column":2},"end":{"line":8,"column":12}}}) : helper))) != null ? stack1 : "") + + ": " + + ((stack1 = container.invokePartial(lookupProperty(partials,"schema"),depth0,{"name":"schema","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ",\n"; +},"6":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isReadOnly: " + + ((stack1 = (((helper = lookupProperty(helpers,"isReadOnly") || container.strict(depth0, "isReadOnly", {"start":{"line":13,"column":16},"end":{"line":13,"column":26}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isReadOnly","hash":{},"data":data,"loc":{"start":{"line":13,"column":13},"end":{"line":13,"column":29}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"8":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isRequired: " + + ((stack1 = (((helper = lookupProperty(helpers,"isRequired") || container.strict(depth0, "isRequired", {"start":{"line":16,"column":16},"end":{"line":16,"column":26}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isRequired","hash":{},"data":data,"loc":{"start":{"line":16,"column":13},"end":{"line":16,"column":29}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"10":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " isNullable: " + + ((stack1 = (((helper = lookupProperty(helpers,"isNullable") || container.strict(depth0, "isNullable", {"start":{"line":19,"column":16},"end":{"line":19,"column":26}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"isNullable","hash":{},"data":data,"loc":{"start":{"line":19,"column":13},"end":{"line":19,"column":29}}}) : helper))) != null ? stack1 : "") + + ",\n"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "{\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":2,"column":0},"end":{"line":4,"column":7}}})) != null ? stack1 : "") + + " properties: {\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"properties"),{"name":"if","hash":{},"fn":container.program(3, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":6,"column":0},"end":{"line":10,"column":7}}})) != null ? stack1 : "") + + " },\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isReadOnly"),{"name":"if","hash":{},"fn":container.program(6, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":12,"column":0},"end":{"line":14,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isRequired"),{"name":"if","hash":{},"fn":container.program(8, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":15,"column":0},"end":{"line":17,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"isNullable"),{"name":"if","hash":{},"fn":container.program(10, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":18,"column":0},"end":{"line":20,"column":7}}})) != null ? stack1 : "") + + "}"; +},"usePartial":true,"useData":true}; + +var partialType = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"typeInterface"),depth0,{"name":"typeInterface","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"3":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"reference",{"name":"equals","hash":{},"fn":container.program(4, data, 0),"inverse":container.program(6, data, 0),"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":19,"column":0}}})) != null ? stack1 : ""); +},"4":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"typeReference"),depth0,{"name":"typeReference","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"6":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"enum",{"name":"equals","hash":{},"fn":container.program(7, data, 0),"inverse":container.program(9, data, 0),"data":data,"loc":{"start":{"line":5,"column":0},"end":{"line":19,"column":0}}})) != null ? stack1 : ""); +},"7":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"typeEnum"),depth0,{"name":"typeEnum","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"9":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"array",{"name":"equals","hash":{},"fn":container.program(10, data, 0),"inverse":container.program(12, data, 0),"data":data,"loc":{"start":{"line":7,"column":0},"end":{"line":19,"column":0}}})) != null ? stack1 : ""); +},"10":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"typeArray"),depth0,{"name":"typeArray","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"12":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"dictionary",{"name":"equals","hash":{},"fn":container.program(13, data, 0),"inverse":container.program(15, data, 0),"data":data,"loc":{"start":{"line":9,"column":0},"end":{"line":19,"column":0}}})) != null ? stack1 : ""); +},"13":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"typeDictionary"),depth0,{"name":"typeDictionary","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"15":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"one-of",{"name":"equals","hash":{},"fn":container.program(16, data, 0),"inverse":container.program(18, data, 0),"data":data,"loc":{"start":{"line":11,"column":0},"end":{"line":19,"column":0}}})) != null ? stack1 : ""); +},"16":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"typeUnion"),depth0,{"name":"typeUnion","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"18":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"any-of",{"name":"equals","hash":{},"fn":container.program(16, data, 0),"inverse":container.program(19, data, 0),"data":data,"loc":{"start":{"line":13,"column":0},"end":{"line":19,"column":0}}})) != null ? stack1 : ""); +},"19":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"all-of",{"name":"equals","hash":{},"fn":container.program(20, data, 0),"inverse":container.program(22, data, 0),"data":data,"loc":{"start":{"line":15,"column":0},"end":{"line":19,"column":0}}})) != null ? stack1 : ""); +},"20":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"typeIntersection"),depth0,{"name":"typeIntersection","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"22":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"typeGeneric"),depth0,{"name":"typeGeneric","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"equals").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"export"),"interface",{"name":"equals","hash":{},"fn":container.program(1, data, 0),"inverse":container.program(3, data, 0),"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":19,"column":11}}})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var partialTypeArray = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "Array<" + + ((stack1 = container.invokePartial(lookupProperty(partials,"type"),lookupProperty(depth0,"link"),{"name":"type","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ">" + + ((stack1 = container.invokePartial(lookupProperty(partials,"isNullable"),depth0,{"name":"isNullable","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"3":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "Array<" + + ((stack1 = container.invokePartial(lookupProperty(partials,"base"),depth0,{"name":"base","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ">" + + ((stack1 = container.invokePartial(lookupProperty(partials,"isNullable"),depth0,{"name":"isNullable","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"link"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.program(3, data, 0),"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":5,"column":9}}})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var partialTypeDictionary = {"1":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "Record" + + ((stack1 = container.invokePartial(lookupProperty(partials,"isNullable"),depth0,{"name":"isNullable","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"3":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "Record" + + ((stack1 = container.invokePartial(lookupProperty(partials,"isNullable"),depth0,{"name":"isNullable","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"link"),{"name":"if","hash":{},"fn":container.program(1, data, 0),"inverse":container.program(3, data, 0),"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":5,"column":9}}})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var partialTypeEnum = {"1":function(container,depth0,helpers,partials,data) { + var stack1; + + return ((stack1 = container.lambda(depth0, depth0)) != null ? stack1 : ""); +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"enumerator").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"enum"),lookupProperty(depth0,"parent"),lookupProperty(depth0,"name"),{"name":"enumerator","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":55}}})) != null ? stack1 : "") + + ((stack1 = container.invokePartial(lookupProperty(partials,"isNullable"),depth0,{"name":"isNullable","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var partialTypeGeneric = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"base"),depth0,{"name":"base","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ((stack1 = container.invokePartial(lookupProperty(partials,"isNullable"),depth0,{"name":"isNullable","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var partialTypeInterface = {"1":function(container,depth0,helpers,partials,data,blockParams,depths) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "{\n" + + ((stack1 = lookupProperty(helpers,"each").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"properties"),{"name":"each","hash":{},"fn":container.program(2, data, 0, blockParams, depths),"inverse":container.noop,"data":data,"loc":{"start":{"line":3,"column":0},"end":{"line":19,"column":9}}})) != null ? stack1 : "") + + "}" + + ((stack1 = container.invokePartial(lookupProperty(partials,"isNullable"),depth0,{"name":"isNullable","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"2":function(container,depth0,helpers,partials,data,blockParams,depths) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"ifdef").call(alias1,lookupProperty(depth0,"description"),lookupProperty(depth0,"deprecated"),{"name":"ifdef","hash":{},"fn":container.program(3, data, 0, blockParams, depths),"inverse":container.noop,"data":data,"loc":{"start":{"line":4,"column":0},"end":{"line":13,"column":10}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depths[1],"parent"),{"name":"if","hash":{},"fn":container.program(8, data, 0, blockParams, depths),"inverse":container.program(10, data, 0, blockParams, depths),"data":data,"loc":{"start":{"line":14,"column":0},"end":{"line":18,"column":7}}})) != null ? stack1 : ""); +},"3":function(container,depth0,helpers,partials,data) { + var stack1, alias1=depth0 != null ? depth0 : (container.nullContext || {}), lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return "/**\n" + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"description"),{"name":"if","hash":{},"fn":container.program(4, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":6,"column":0},"end":{"line":8,"column":7}}})) != null ? stack1 : "") + + ((stack1 = lookupProperty(helpers,"if").call(alias1,lookupProperty(depth0,"deprecated"),{"name":"if","hash":{},"fn":container.program(6, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":9,"column":0},"end":{"line":11,"column":7}}})) != null ? stack1 : "") + + " */\n"; +},"4":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return " * " + + ((stack1 = lookupProperty(helpers,"escapeComment").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"description"),{"name":"escapeComment","hash":{},"data":data,"loc":{"start":{"line":7,"column":3},"end":{"line":7,"column":34}}})) != null ? stack1 : "") + + "\n"; +},"6":function(container,depth0,helpers,partials,data) { + return " * @deprecated\n"; +},"8":function(container,depth0,helpers,partials,data,blockParams,depths) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"isReadOnly"),depth0,{"name":"isReadOnly","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":15,"column":18},"end":{"line":15,"column":22}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"name","hash":{},"data":data,"loc":{"start":{"line":15,"column":15},"end":{"line":15,"column":25}}}) : helper))) != null ? stack1 : "") + + ((stack1 = container.invokePartial(lookupProperty(partials,"isRequired"),depth0,{"name":"isRequired","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ": " + + ((stack1 = container.invokePartial(lookupProperty(partials,"type"),depth0,{"name":"type","hash":{"parent":lookupProperty(depths[1],"parent")},"data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ";\n"; +},"10":function(container,depth0,helpers,partials,data) { + var stack1, helper, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"isReadOnly"),depth0,{"name":"isReadOnly","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ((stack1 = (((helper = lookupProperty(helpers,"name") || container.strict(depth0, "name", {"start":{"line":17,"column":18},"end":{"line":17,"column":22}} ))),(typeof helper === "function" ? helper.call(depth0 != null ? depth0 : (container.nullContext || {}),{"name":"name","hash":{},"data":data,"loc":{"start":{"line":17,"column":15},"end":{"line":17,"column":25}}}) : helper))) != null ? stack1 : "") + + ((stack1 = container.invokePartial(lookupProperty(partials,"isRequired"),depth0,{"name":"isRequired","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ": " + + ((stack1 = container.invokePartial(lookupProperty(partials,"type"),depth0,{"name":"type","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ";\n"; +},"12":function(container,depth0,helpers,partials,data) { + return "any"; +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data,blockParams,depths) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"if").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"properties"),{"name":"if","hash":{},"fn":container.program(1, data, 0, blockParams, depths),"inverse":container.program(12, data, 0, blockParams, depths),"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":23,"column":9}}})) != null ? stack1 : ""); +},"usePartial":true,"useData":true,"useDepths":true}; + +var partialTypeIntersection = {"1":function(container,depth0,helpers,partials,data) { + var stack1; + + return ((stack1 = container.lambda(depth0, depth0)) != null ? stack1 : ""); +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"intersection").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"properties"),lookupProperty(depth0,"parent"),{"name":"intersection","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":60}}})) != null ? stack1 : "") + + ((stack1 = container.invokePartial(lookupProperty(partials,"isNullable"),depth0,{"name":"isNullable","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var partialTypeReference = {"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = container.invokePartial(lookupProperty(partials,"base"),depth0,{"name":"base","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : "") + + ((stack1 = container.invokePartial(lookupProperty(partials,"isNullable"),depth0,{"name":"isNullable","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +var partialTypeUnion = {"1":function(container,depth0,helpers,partials,data) { + var stack1; + + return ((stack1 = container.lambda(depth0, depth0)) != null ? stack1 : ""); +},"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) { + var stack1, lookupProperty = container.lookupProperty || function(parent, propertyName) { + if (Object.prototype.hasOwnProperty.call(parent, propertyName)) { + return parent[propertyName]; + } + return undefined + }; + + return ((stack1 = lookupProperty(helpers,"union").call(depth0 != null ? depth0 : (container.nullContext || {}),lookupProperty(depth0,"properties"),lookupProperty(depth0,"parent"),{"name":"union","hash":{},"fn":container.program(1, data, 0),"inverse":container.noop,"data":data,"loc":{"start":{"line":1,"column":0},"end":{"line":1,"column":46}}})) != null ? stack1 : "") + + ((stack1 = container.invokePartial(lookupProperty(partials,"isNullable"),depth0,{"name":"isNullable","data":data,"helpers":helpers,"partials":partials,"decorators":container.decorators})) != null ? stack1 : ""); +},"usePartial":true,"useData":true}; + +const registerHandlebarHelpers = (root) => { + runtime.registerHelper('ifdef', function (...args) { + const options = args.pop(); + if (!args.every(value => !value)) { + return options.fn(this); + } + return options.inverse(this); + }); + runtime.registerHelper('replace', function (find, replace, options) { + var string = options.fn(this); + let re = new RegExp(find, 'g'); + return string.replace(re, replace); + }); + runtime.registerHelper('log', function (content) { + console.log(content.fn(this)); + return ''; + }); + runtime.registerHelper('if_eq', function (a, options) { + let string = a; + if (string.includes('Request')) + return options.fn(this); + else + return options.inverse(this); + }); + runtime.registerHelper('deleteUserId', function (options) { + let string = options.fn(this); + let re = new RegExp('userId: string,', 'g'); + return string.replace(re, ''); + }); + runtime.registerHelper('capitalizeFirst', function (a, options) { + return a.charAt(0).toUpperCase() + a.slice(1); + }); + runtime.registerHelper('equals', function (a, b, options) { + return a === b ? options.fn(this) : options.inverse(this); + }); + runtime.registerHelper('notEquals', function (a, b, options) { + return a !== b ? options.fn(this) : options.inverse(this); + }); + runtime.registerHelper('containsSpaces', function (value, options) { + return /\s+/.test(value) ? options.fn(this) : options.inverse(this); + }); + runtime.registerHelper('union', function (properties, parent, options) { + const type = runtime.partials['type']; + const types = properties.map(property => type({ ...root, ...property, parent })); + const uniqueTypes = types.filter(unique); + let uniqueTypesString = uniqueTypes.join(' | '); + if (uniqueTypes.length > 1) { + uniqueTypesString = `(${uniqueTypesString})`; + } + return options.fn(uniqueTypesString); + }); + runtime.registerHelper('intersection', function (properties, parent, options) { + const type = runtime.partials['type']; + const types = properties.map(property => type({ ...root, ...property, parent })); + const uniqueTypes = types.filter(unique); + let uniqueTypesString = uniqueTypes.join(' & '); + if (uniqueTypes.length > 1) { + uniqueTypesString = `(${uniqueTypesString})`; + } + return options.fn(uniqueTypesString); + }); + runtime.registerHelper('enumerator', function (enumerators, parent, name, options) { + if (!root.useUnionTypes && parent && name) { + return `${parent}.${name}`; + } + return options.fn(enumerators + .map(enumerator => enumerator.value) + .filter(unique) + .join(' | ')); + }); + runtime.registerHelper('escapeComment', function (value) { + return value + .replace(/\*\//g, '*') + .replace(/\/\*/g, '*') + .replace(/\r?\n(.*)/g, (_, w) => `${os.EOL} * ${w.trim()}`); + }); + runtime.registerHelper('escapeDescription', function (value) { + return value.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\${/g, '\\${'); + }); + runtime.registerHelper('camelCase', function (value) { + return camelCase(value); + }); +}; + +/** + * Read all the Handlebar templates that we need and return on wrapper object + * so we can easily access the templates in out generator / write functions. + */ +const registerHandlebarTemplates = (root) => { + registerHandlebarHelpers(root); + // Main templates (entry points for the files we write to disk) + const templates = { + index: runtime.template(templateIndex), + client: runtime.template(templateClient), + exports: { + model: runtime.template(templateExportModel), + schema: runtime.template(templateExportSchema), + service: runtime.template(templateExportService), + }, + core: { + settings: runtime.template(templateCoreSettings), + apiError: runtime.template(templateCoreApiError), + apiRequestOptions: runtime.template(templateCoreApiRequestOptions), + apiResult: runtime.template(templateCoreApiResult), + cancelablePromise: runtime.template(templateCancelablePromise), + request: runtime.template(templateCoreRequest), + baseHttpRequest: runtime.template(templateCoreBaseHttpRequest), + httpRequest: runtime.template(templateCoreHttpRequest), + }, + }; + // Partials for the generations of the models, services, etc. + runtime.registerPartial('exportEnum', runtime.template(partialExportEnum)); + runtime.registerPartial('exportInterface', runtime.template(partialExportInterface)); + runtime.registerPartial('exportComposition', runtime.template(partialExportComposition)); + runtime.registerPartial('exportType', runtime.template(partialExportType)); + runtime.registerPartial('header', runtime.template(partialHeader)); + runtime.registerPartial('isNullable', runtime.template(partialIsNullable)); + runtime.registerPartial('isReadOnly', runtime.template(partialIsReadOnly)); + runtime.registerPartial('isRequired', runtime.template(partialIsRequired)); + runtime.registerPartial('parameters', runtime.template(partialParameters)); + runtime.registerPartial('result', runtime.template(partialResult)); + runtime.registerPartial('schema', runtime.template(partialSchema)); + runtime.registerPartial('schemaArray', runtime.template(partialSchemaArray)); + runtime.registerPartial('schemaDictionary', runtime.template(partialSchemaDictionary)); + runtime.registerPartial('schemaEnum', runtime.template(partialSchemaEnum)); + runtime.registerPartial('schemaGeneric', runtime.template(partialSchemaGeneric)); + runtime.registerPartial('schemaInterface', runtime.template(partialSchemaInterface)); + runtime.registerPartial('schemaComposition', runtime.template(partialSchemaComposition)); + runtime.registerPartial('type', runtime.template(partialType)); + runtime.registerPartial('typeArray', runtime.template(partialTypeArray)); + runtime.registerPartial('typeDictionary', runtime.template(partialTypeDictionary)); + runtime.registerPartial('typeEnum', runtime.template(partialTypeEnum)); + runtime.registerPartial('typeGeneric', runtime.template(partialTypeGeneric)); + runtime.registerPartial('typeInterface', runtime.template(partialTypeInterface)); + runtime.registerPartial('typeReference', runtime.template(partialTypeReference)); + runtime.registerPartial('typeUnion', runtime.template(partialTypeUnion)); + runtime.registerPartial('typeIntersection', runtime.template(partialTypeIntersection)); + runtime.registerPartial('base', runtime.template(partialBase)); + // Generic functions used in 'request' file @see src/templates/core/request.hbs for more info + runtime.registerPartial('functions/catchErrorCodes', runtime.template(functionCatchErrorCodes)); + runtime.registerPartial('functions/getFormData', runtime.template(functionGetFormData)); + runtime.registerPartial('functions/getQueryString', runtime.template(functionGetQueryString)); + runtime.registerPartial('functions/getUrl', runtime.template(functionGetUrl)); + runtime.registerPartial('functions/isBlob', runtime.template(functionIsBlob)); + runtime.registerPartial('functions/isDefined', runtime.template(functionIsDefined)); + runtime.registerPartial('functions/isFormData', runtime.template(functionIsFormData)); + runtime.registerPartial('functions/isString', runtime.template(functionIsString)); + runtime.registerPartial('functions/isStringWithValue', runtime.template(functionIsStringWithValue)); + runtime.registerPartial('functions/isSuccess', runtime.template(functionIsSuccess)); + runtime.registerPartial('functions/base64', runtime.template(functionBase64)); + runtime.registerPartial('functions/resolve', runtime.template(functionResolve)); + // Specific files for the fetch client implementation + runtime.registerPartial('fetch/getHeaders', runtime.template(fetchGetHeaders)); + runtime.registerPartial('fetch/getRequestBody', runtime.template(fetchGetRequestBody)); + runtime.registerPartial('fetch/getResponseBody', runtime.template(fetchGetResponseBody)); + runtime.registerPartial('fetch/getResponseHeader', runtime.template(fetchGetResponseHeader)); + runtime.registerPartial('fetch/sendRequest', runtime.template(fetchSendRequest)); + runtime.registerPartial('fetch/request', runtime.template(fetchRequest)); + // Specific files for the xhr client implementation + runtime.registerPartial('xhr/getHeaders', runtime.template(xhrGetHeaders)); + runtime.registerPartial('xhr/getRequestBody', runtime.template(xhrGetRequestBody)); + runtime.registerPartial('xhr/getResponseBody', runtime.template(xhrGetResponseBody)); + runtime.registerPartial('xhr/getResponseHeader', runtime.template(xhrGetResponseHeader)); + runtime.registerPartial('xhr/sendRequest', runtime.template(xhrSendRequest)); + runtime.registerPartial('xhr/request', runtime.template(xhrRequest)); + // Specific files for the node client implementation + runtime.registerPartial('node/getHeaders', runtime.template(nodeGetHeaders)); + runtime.registerPartial('node/getRequestBody', runtime.template(nodeGetRequestBody)); + runtime.registerPartial('node/getResponseBody', runtime.template(nodeGetResponseBody)); + runtime.registerPartial('node/getResponseHeader', runtime.template(nodeGetResponseHeader)); + runtime.registerPartial('node/sendRequest', runtime.template(nodeSendRequest)); + runtime.registerPartial('node/request', runtime.template(nodeRequest)); + // Specific files for the axios client implementation + runtime.registerPartial('axios/getHeaders', runtime.template(axiosGetHeaders)); + runtime.registerPartial('axios/getRequestBody', runtime.template(axiosGetRequestBody)); + runtime.registerPartial('axios/getResponseBody', runtime.template(axiosGetResponseBody)); + runtime.registerPartial('axios/getResponseHeader', runtime.template(axiosGetResponseHeader)); + runtime.registerPartial('axios/sendRequest', runtime.template(axiosSendRequest)); + runtime.registerPartial('axios/request', runtime.template(axiosRequest)); + // Specific files for the angular client implementation + runtime.registerPartial('angular/getHeaders', runtime.template(angularGetHeaders)); + runtime.registerPartial('angular/getRequestBody', runtime.template(angularGetRequestBody)); + runtime.registerPartial('angular/getResponseBody', runtime.template(angularGetResponseBody)); + runtime.registerPartial('angular/getResponseHeader', runtime.template(angularGetResponseHeader)); + runtime.registerPartial('angular/sendRequest', runtime.template(angularSendRequest)); + runtime.registerPartial('angular/request', runtime.template(angularRequest)); + return templates; +}; + +const writeFile = fsExtra.writeFile; +const copyFile = fsExtra.copyFile; +const exists = fsExtra.pathExists; +const mkdir = fsExtra.mkdirp; +const rmdir = fsExtra.remove; + +const isSubDirectory = (parent, child) => { + return path.relative(child, parent).startsWith('..'); +}; + +const formatCode = (s) => { + let indent = 0; + let lines = s.split(os.EOL); + lines = lines.map(line => { + line = line.trim().replace(/^\*/g, ' *'); + let i = indent; + if (line.endsWith('(') || line.endsWith('{') || line.endsWith('[')) { + indent++; + } + if ((line.startsWith(')') || line.startsWith('}') || line.startsWith(']')) && i) { + indent--; + i--; + } + const result = `${'\t'.repeat(i)}${line}`; + if (result.trim() === '') { + return ''; + } + return result; + }); + return lines.join(os.EOL); +}; + +const formatIndentation = (s, indent) => { + let lines = s.split(os.EOL); + lines = lines.map(line => { + switch (indent) { + case exports.Indent.SPACE_4: + return line.replace(/\t/g, ' '); + case exports.Indent.SPACE_2: + return line.replace(/\t/g, ' '); + case exports.Indent.TAB: + return line; // Default output is tab formatted + } + }); + // Make sure we have a blank line at the end + const content = lines.join(os.EOL); + return `${content}${os.EOL}`; +}; + +/** + * Generate the HttpRequest filename based on the selected client + * @param httpClient The selected httpClient (fetch, xhr, node or axios) + */ +const getHttpRequestName = (httpClient) => { + switch (httpClient) { + case exports.HttpClient.FETCH: + return 'FetchHttpRequest'; + case exports.HttpClient.XHR: + return 'XHRHttpRequest'; + case exports.HttpClient.NODE: + return 'NodeHttpRequest'; + case exports.HttpClient.AXIOS: + return 'AxiosHttpRequest'; + case exports.HttpClient.ANGULAR: + return 'AngularHttpRequest'; + } +}; + +const sortModelsByName = (models) => { + return models.sort((a, b) => { + const nameA = a.name.toLowerCase(); + const nameB = b.name.toLowerCase(); + return nameA.localeCompare(nameB, 'en'); + }); +}; + +const sortServicesByName = (services) => { + return services.sort((a, b) => { + const nameA = a.name.toLowerCase(); + const nameB = b.name.toLowerCase(); + return nameA.localeCompare(nameB, 'en'); + }); +}; + +/** + * Generate the OpenAPI client index file using the Handlebar template and write it to disk. + * The index file just contains all the exports you need to use the client as a standalone + * library. But yuo can also import individual models and services directly. + * @param client Client object, containing, models, schemas and services + * @param templates The loaded handlebar templates + * @param outputPath Directory to write the generated files to + * @param httpClient The selected httpClient (fetch, xhr, node or axios) + * @param clientName Custom client class name + * @param indent Indentation options (4, 2 or tab) + * @param postfix Service name postfix + */ +const writeClientClass = async (client, templates, outputPath, httpClient, clientName, indent, postfix) => { + const templateResult = templates.client({ + clientName, + httpClient, + postfix, + server: client.server, + version: client.version, + models: sortModelsByName(client.models), + services: sortServicesByName(client.services), + httpRequest: getHttpRequestName(httpClient), + }); + await writeFile(path.resolve(outputPath, `${clientName}.ts`), formatIndentation(formatCode(templateResult), indent)); +}; + +/** + * Generate OpenAPI core files, this includes the basic boilerplate code to handle requests. + * @param client Client object, containing, models, schemas and services + * @param templates The loaded handlebar templates + * @param outputPath Directory to write the generated files to + * @param httpClient The selected httpClient (fetch, xhr, node or axios) + * @param indent Indentation options (4, 2 or tab) + * @param clientName Custom client class name + * @param request Path to custom request file + */ +const writeClientCore = async (client, templates, outputPath, httpClient, indent, clientName, request) => { + const httpRequest = getHttpRequestName(httpClient); + const context = { + httpClient, + clientName, + httpRequest, + server: client.server, + version: client.version, + }; + await writeFile(path.resolve(outputPath, 'OpenAPI.ts'), formatIndentation(templates.core.settings(context), indent)); + await writeFile(path.resolve(outputPath, 'ApiError.ts'), formatIndentation(templates.core.apiError(context), indent)); + await writeFile(path.resolve(outputPath, 'ApiRequestOptions.ts'), formatIndentation(templates.core.apiRequestOptions(context), indent)); + await writeFile(path.resolve(outputPath, 'ApiResult.ts'), formatIndentation(templates.core.apiResult(context), indent)); + await writeFile(path.resolve(outputPath, 'CancelablePromise.ts'), formatIndentation(templates.core.cancelablePromise(context), indent)); + await writeFile(path.resolve(outputPath, 'request.ts'), formatIndentation(templates.core.request(context), indent)); + if (isDefined(clientName)) { + await writeFile(path.resolve(outputPath, 'BaseHttpRequest.ts'), formatIndentation(templates.core.baseHttpRequest(context), indent)); + await writeFile(path.resolve(outputPath, `${httpRequest}.ts`), formatIndentation(templates.core.httpRequest(context), indent)); + } + if (request) { + const requestFile = path.resolve(process.cwd(), request); + const requestFileExists = await exists(requestFile); + if (!requestFileExists) { + throw new Error(`Custom request file "${requestFile}" does not exists`); + } + await copyFile(requestFile, path.resolve(outputPath, 'request.ts')); + } +}; + +/** + * Generate the OpenAPI client index file using the Handlebar template and write it to disk. + * The index file just contains all the exports you need to use the client as a standalone + * library. But yuo can also import individual models and services directly. + * @param client Client object, containing, models, schemas and services + * @param templates The loaded handlebar templates + * @param outputPath Directory to write the generated files to + * @param useUnionTypes Use union types instead of enums + * @param exportCore Generate core + * @param exportServices Generate services + * @param exportModels Generate models + * @param exportSchemas Generate schemas + * @param postfixServices Service name postfix + * @param postfixModels Model name postfix + * @param clientName Custom client class name + */ +const writeClientIndex = async (client, templates, outputPath, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas, postfixServices, postfixModels, clientName) => { + const templateResult = templates.index({ + exportCore, + exportServices, + exportModels, + exportSchemas, + useUnionTypes, + postfixServices, + postfixModels, + clientName, + server: client.server, + version: client.version, + models: sortModelsByName(client.models), + services: sortServicesByName(client.services), + exportClient: isDefined(clientName), + }); + await writeFile(path.resolve(outputPath, 'index.ts'), templateResult); +}; + +/** + * Generate Models using the Handlebar template and write to disk. + * @param models Array of Models to write + * @param templates The loaded handlebar templates + * @param outputPath Directory to write the generated files to + * @param httpClient The selected httpClient (fetch, xhr, node or axios) + * @param useUnionTypes Use union types instead of enums + * @param indent Indentation options (4, 2 or tab) + */ +const writeClientModels = async (models, templates, outputPath, httpClient, useUnionTypes, indent) => { + for (const model of models) { + const file = path.resolve(outputPath, `${model.name}.ts`); + const templateResult = templates.exports.model({ + ...model, + httpClient, + useUnionTypes, + }); + await writeFile(file, formatIndentation(formatCode(templateResult), indent)); + } +}; + +/** + * Generate Schemas using the Handlebar template and write to disk. + * @param models Array of Models to write + * @param templates The loaded handlebar templates + * @param outputPath Directory to write the generated files to + * @param httpClient The selected httpClient (fetch, xhr, node or axios) + * @param useUnionTypes Use union types instead of enums + * @param indent Indentation options (4, 2 or tab) + */ +const writeClientSchemas = async (models, templates, outputPath, httpClient, useUnionTypes, indent) => { + for (const model of models) { + const file = path.resolve(outputPath, `$${model.name}.ts`); + const templateResult = templates.exports.schema({ + ...model, + httpClient, + useUnionTypes, + }); + await writeFile(file, formatIndentation(formatCode(templateResult), indent)); + } +}; + +/** + * Generate Services using the Handlebar template and write to disk. + * @param services Array of Services to write + * @param templates The loaded handlebar templates + * @param outputPath Directory to write the generated files to + * @param httpClient The selected httpClient (fetch, xhr, node or axios) + * @param useUnionTypes Use union types instead of enums + * @param useOptions Use options or arguments functions + * @param indent Indentation options (4, 2 or tab) + * @param postfix Service name postfix + * @param clientName Custom client class name + */ +const writeClientServices = async (services, templates, outputPath, httpClient, useUnionTypes, useOptions, indent, postfix, clientName) => { + for (const service of services) { + const file = path.resolve(outputPath, `${service.name}${postfix}.ts`); + const templateResult = templates.exports.service({ + ...service, + httpClient, + useUnionTypes, + useOptions, + postfix, + exportClient: isDefined(clientName), + }); + await writeFile(file, formatIndentation(formatCode(templateResult), indent)); + } +}; + +/** + * Write our OpenAPI client, using the given templates at the given output + * @param client Client object with all the models, services, etc. + * @param templates Templates wrapper with all loaded Handlebars templates + * @param output The relative location of the output directory + * @param httpClient The selected httpClient (fetch, xhr, node or axios) + * @param useOptions Use options or arguments functions + * @param useUnionTypes Use union types instead of enums + * @param exportCore Generate core client classes + * @param exportServices Generate services + * @param exportModels Generate models + * @param exportSchemas Generate schemas + * @param exportSchemas Generate schemas + * @param indent Indentation options (4, 2 or tab) + * @param postfixServices Service name postfix + * @param postfixModels Model name postfix + * @param clientName Custom client class name + * @param request Path to custom request file + */ +const writeClient = async (client, templates, output, httpClient, useOptions, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas, indent, postfixServices, postfixModels, clientName, request) => { + const outputPath = path.resolve(process.cwd(), output); + const outputPathCore = path.resolve(outputPath, 'core'); + const outputPathModels = path.resolve(outputPath, 'models/Interfaces/GluonInterfaces'); + const outputPathSchemas = path.resolve(outputPath, 'schemas'); + const outputPathServices = path.resolve(outputPath, 'services/Gluon_services'); + if (!isSubDirectory(process.cwd(), output)) { + throw new Error(`Output folder is not a subdirectory of the current working directory`); + } + if (exportCore) { + await rmdir(outputPathCore); + await mkdir(outputPathCore); + await writeClientCore(client, templates, outputPathCore, httpClient, indent, clientName, request); + } + if (exportServices) { + await rmdir(outputPathServices); + await mkdir(outputPathServices); + await writeClientServices(client.services, templates, outputPathServices, httpClient, useUnionTypes, useOptions, indent, postfixServices, clientName); + } + if (exportSchemas) { + await rmdir(outputPathSchemas); + await mkdir(outputPathSchemas); + await writeClientSchemas(client.models, templates, outputPathSchemas, httpClient, useUnionTypes, indent); + } + if (exportModels) { + await rmdir(outputPathModels); + await mkdir(outputPathModels); + await writeClientModels(client.models, templates, outputPathModels, httpClient, useUnionTypes, indent); + } + if (isDefined(clientName)) { + await mkdir(outputPath); + await writeClientClass(client, templates, outputPath, httpClient, clientName, indent, postfixServices); + } + if (exportCore || exportServices || exportSchemas || exportModels) { + await mkdir(outputPath); + await writeClientIndex(client, templates, outputPath, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas, postfixServices, postfixModels, clientName); + } +}; + +/** + * Generate the OpenAPI client. This method will read the OpenAPI specification and based on the + * given language it will generate the client, including the typed models, validation schemas, + * service layer, etc. + * @param input The relative location of the OpenAPI spec + * @param output The relative location of the output directory + * @param httpClient The selected httpClient (fetch, xhr, node or axios) + * @param clientName Custom client class name + * @param useOptions Use options or arguments functions + * @param useUnionTypes Use union types instead of enums + * @param exportCore Generate core client classes + * @param exportServices Generate services + * @param exportModels Generate models + * @param exportSchemas Generate schemas + * @param indent Indentation options (4, 2 or tab) + * @param postfixServices Service name postfix + * @param postfixModels Model name postfix + * @param request Path to custom request file + * @param write Write the files to disk (true or false) + */ +const generate = async ({ input, output, httpClient = exports.HttpClient.FETCH, clientName, useOptions = false, useUnionTypes = false, exportCore = true, exportServices = true, exportModels = true, exportSchemas = false, indent = exports.Indent.SPACE_4, postfixServices = 'Service', postfixModels = '', request, write = true, }) => { + const openApi = isString(input) ? await getOpenApiSpec(input) : input; + const openApiVersion = getOpenApiVersion(openApi); + const templates = registerHandlebarTemplates({ + httpClient, + useUnionTypes, + useOptions, + }); + switch (openApiVersion) { + case OpenApiVersion.V2: { + const client = parse$1(openApi); + const clientFinal = postProcessClient(client); + if (!write) + break; + await writeClient(clientFinal, templates, output, httpClient, useOptions, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas, indent, postfixServices, postfixModels, clientName, request); + break; + } + case OpenApiVersion.V3: { + const client = parse(openApi); + const clientFinal = postProcessClient(client); + if (!write) + break; + await writeClient(clientFinal, templates, output, httpClient, useOptions, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas, indent, postfixServices, postfixModels, clientName, request); + break; + } + } +}; +var index = { + HttpClient: exports.HttpClient, + generate, +}; + +exports.default = index; +exports.generate = generate; diff --git a/package.json b/package.json index cc38c8d10..4f3f7d9eb 100644 --- a/package.json +++ b/package.json @@ -120,7 +120,7 @@ "typescript": "4.8.4", "zone.js": "0.11.8" }, - "overrides" : { + "overrides": { "rollup": "3.2.3" } } diff --git a/rollup.config.mjs b/rollup.config.mjs index df7373395..ee638bf6f 100644 --- a/rollup.config.mjs +++ b/rollup.config.mjs @@ -27,7 +27,7 @@ const handlebarsPlugin = () => ({ strict: true, noEscape: true, preventIndent: true, - knownHelpersOnly: true, + knownHelpersOnly: false, knownHelpers: { ifdef: true, equals: true, diff --git a/src/index.ts b/src/index.ts index e63919085..f81170d60 100644 --- a/src/index.ts +++ b/src/index.ts @@ -95,7 +95,7 @@ export const generate = async ({ postfixServices, postfixModels, clientName, - request + request, ); break; } @@ -119,7 +119,7 @@ export const generate = async ({ postfixServices, postfixModels, clientName, - request + request, ); break; } diff --git a/src/openApi/v2/parser/getModel.ts b/src/openApi/v2/parser/getModel.ts index 22f3528aa..727b14268 100644 --- a/src/openApi/v2/parser/getModel.ts +++ b/src/openApi/v2/parser/getModel.ts @@ -12,7 +12,7 @@ export const getModel = ( openApi: OpenApi, definition: OpenApiSchema, isDefinition: boolean = false, - name: string = '' + name: string = '', ): Model => { const model: Model = { name, diff --git a/src/openApi/v2/parser/getModelComposition.ts b/src/openApi/v2/parser/getModelComposition.ts index 6b5e4c305..24a60c62e 100644 --- a/src/openApi/v2/parser/getModelComposition.ts +++ b/src/openApi/v2/parser/getModelComposition.ts @@ -14,7 +14,7 @@ export const getModelComposition = ( definition: OpenApiSchema, definitions: OpenApiSchema[], type: 'one-of' | 'any-of' | 'all-of', - getModel: GetModelFn + getModel: GetModelFn, ): ModelComposition => { const composition: ModelComposition = { type, @@ -45,7 +45,7 @@ export const getModelComposition = ( openApi, definition.required, definitions, - getModel + getModel, ); requiredProperties.forEach(requiredProperty => { composition.imports.push(...requiredProperty.imports); diff --git a/src/openApi/v2/parser/getOperation.ts b/src/openApi/v2/parser/getOperation.ts index 9aa157460..c09f91d3a 100644 --- a/src/openApi/v2/parser/getOperation.ts +++ b/src/openApi/v2/parser/getOperation.ts @@ -17,7 +17,7 @@ export const getOperation = ( method: string, tag: string, op: OpenApiOperation, - pathParams: OperationParameters + pathParams: OperationParameters, ): Operation => { const serviceName = getServiceName(tag); const operationName = getOperationName(url, method, op.operationId); diff --git a/src/openApi/v2/parser/getOperationName.ts b/src/openApi/v2/parser/getOperationName.ts index 124bf66bd..a0bb3cc0a 100644 --- a/src/openApi/v2/parser/getOperationName.ts +++ b/src/openApi/v2/parser/getOperationName.ts @@ -11,7 +11,7 @@ export const getOperationName = (url: string, method: string, operationId?: stri operationId .replace(/^[^a-zA-Z]+/g, '') .replace(/[^\w\-]+/g, '-') - .trim() + .trim(), ); } diff --git a/src/openApi/v2/parser/getOperationParameterDefault.ts b/src/openApi/v2/parser/getOperationParameterDefault.ts index 291b3adbb..3c43e8404 100644 --- a/src/openApi/v2/parser/getOperationParameterDefault.ts +++ b/src/openApi/v2/parser/getOperationParameterDefault.ts @@ -3,7 +3,7 @@ import type { OpenApiParameter } from '../interfaces/OpenApiParameter'; export const getOperationParameterDefault = ( parameter: OpenApiParameter, - operationParameter: OperationParameter + operationParameter: OperationParameter, ): string | undefined => { if (parameter.default === undefined) { return undefined; diff --git a/src/openApi/v2/parser/getOperationResponse.ts b/src/openApi/v2/parser/getOperationResponse.ts index 8f6c3ca56..a028cfe98 100644 --- a/src/openApi/v2/parser/getOperationResponse.ts +++ b/src/openApi/v2/parser/getOperationResponse.ts @@ -10,7 +10,7 @@ import { getType } from './getType'; export const getOperationResponse = ( openApi: OpenApi, response: OpenApiResponse, - responseCode: number + responseCode: number, ): OperationResponse => { const operationResponse: OperationResponse = { in: 'response', diff --git a/src/openApi/v2/parser/getRef.spec.ts b/src/openApi/v2/parser/getRef.spec.ts index c475208b2..ab86a4498 100644 --- a/src/openApi/v2/parser/getRef.spec.ts +++ b/src/openApi/v2/parser/getRef.spec.ts @@ -23,8 +23,8 @@ describe('getRef', () => { }, { $ref: '#/definitions/Example', - } - ) + }, + ), ).toEqual({ description: 'This is an Example model ', type: 'integer', diff --git a/src/openApi/v2/parser/getRef.ts b/src/openApi/v2/parser/getRef.ts index f92dfcf67..ad3a7341f 100644 --- a/src/openApi/v2/parser/getRef.ts +++ b/src/openApi/v2/parser/getRef.ts @@ -18,7 +18,7 @@ export const getRef = (openApi: OpenApi, item: T & OpenApiReference): T => { let result: any = openApi; paths.forEach(path => { const decodedPath = decodeURIComponent( - path.replace(ESCAPED_REF_SLASH, '/').replace(ESCAPED_REF_TILDE, '~') + path.replace(ESCAPED_REF_SLASH, '/').replace(ESCAPED_REF_TILDE, '~'), ); if (result.hasOwnProperty(decodedPath)) { result = result[decodedPath]; diff --git a/src/openApi/v2/parser/getRequiredPropertiesFromComposition.ts b/src/openApi/v2/parser/getRequiredPropertiesFromComposition.ts index 0b1f1859f..5d38968a9 100644 --- a/src/openApi/v2/parser/getRequiredPropertiesFromComposition.ts +++ b/src/openApi/v2/parser/getRequiredPropertiesFromComposition.ts @@ -11,7 +11,7 @@ export const getRequiredPropertiesFromComposition = ( openApi: OpenApi, required: string[], definitions: OpenApiSchema[], - getModel: GetModelFn + getModel: GetModelFn, ): Model[] => { return definitions .reduce((properties, definition) => { diff --git a/src/openApi/v2/parser/getServer.spec.ts b/src/openApi/v2/parser/getServer.spec.ts index 4eddc72c8..a8df90339 100644 --- a/src/openApi/v2/parser/getServer.spec.ts +++ b/src/openApi/v2/parser/getServer.spec.ts @@ -13,7 +13,7 @@ describe('getServer', () => { basePath: '/api', schemes: ['http', 'https'], paths: {}, - }) + }), ).toEqual('http://localhost:8080/api'); }); }); diff --git a/src/openApi/v3/interfaces/OpenApiParameter.d.ts b/src/openApi/v3/interfaces/OpenApiParameter.d.ts index 7172feb7b..f52f6d847 100644 --- a/src/openApi/v3/interfaces/OpenApiParameter.d.ts +++ b/src/openApi/v3/interfaces/OpenApiParameter.d.ts @@ -10,7 +10,7 @@ export interface OpenApiParameter extends OpenApiReference { name: string; in: 'path' | 'query' | 'header' | 'formData' | 'cookie'; description?: string; - required?: boolean; + required: boolean; nullable?: boolean; deprecated?: boolean; allowEmptyValue?: boolean; diff --git a/src/openApi/v3/parser/getModel.ts b/src/openApi/v3/parser/getModel.ts index 9e9c60a98..f69b9182d 100644 --- a/src/openApi/v3/parser/getModel.ts +++ b/src/openApi/v3/parser/getModel.ts @@ -13,7 +13,7 @@ export const getModel = ( openApi: OpenApi, definition: OpenApiSchema, isDefinition: boolean = false, - name: string = '' + name: string = '', ): Model => { const model: Model = { name, diff --git a/src/openApi/v3/parser/getModelComposition.ts b/src/openApi/v3/parser/getModelComposition.ts index 2c27d1815..a70d3adee 100644 --- a/src/openApi/v3/parser/getModelComposition.ts +++ b/src/openApi/v3/parser/getModelComposition.ts @@ -14,7 +14,7 @@ export const getModelComposition = ( definition: OpenApiSchema, definitions: OpenApiSchema[], type: 'one-of' | 'any-of' | 'all-of', - getModel: GetModelFn + getModel: GetModelFn, ): ModelComposition => { const composition: ModelComposition = { type, @@ -46,7 +46,7 @@ export const getModelComposition = ( openApi, definition.required, definitions, - getModel + getModel, ); requiredProperties.forEach(requiredProperty => { composition.imports.push(...requiredProperty.imports); diff --git a/src/openApi/v3/parser/getModelProperties.ts b/src/openApi/v3/parser/getModelProperties.ts index 6e25ca833..03818ddec 100644 --- a/src/openApi/v3/parser/getModelProperties.ts +++ b/src/openApi/v3/parser/getModelProperties.ts @@ -14,7 +14,7 @@ export const getModelProperties = ( openApi: OpenApi, definition: OpenApiSchema, getModel: GetModelFn, - parent?: Model + parent?: Model, ): Model[] => { const models: Model[] = []; const discriminator = findOneOfParentDiscriminator(openApi, parent); diff --git a/src/openApi/v3/parser/getOperation.ts b/src/openApi/v3/parser/getOperation.ts index aee4bd0c2..07da4f15a 100644 --- a/src/openApi/v3/parser/getOperation.ts +++ b/src/openApi/v3/parser/getOperation.ts @@ -20,7 +20,7 @@ export const getOperation = ( method: string, tag: string, op: OpenApiOperation, - pathParams: OperationParameters + pathParams: OperationParameters, ): Operation => { const serviceName = getServiceName(tag); const operationName = getOperationName(url, method, op.operationId); diff --git a/src/openApi/v3/parser/getOperationName.ts b/src/openApi/v3/parser/getOperationName.ts index 124bf66bd..a0bb3cc0a 100644 --- a/src/openApi/v3/parser/getOperationName.ts +++ b/src/openApi/v3/parser/getOperationName.ts @@ -11,7 +11,7 @@ export const getOperationName = (url: string, method: string, operationId?: stri operationId .replace(/^[^a-zA-Z]+/g, '') .replace(/[^\w\-]+/g, '-') - .trim() + .trim(), ); } diff --git a/src/openApi/v3/parser/getOperationParameter.ts b/src/openApi/v3/parser/getOperationParameter.ts index 97a719c96..5cd368752 100644 --- a/src/openApi/v3/parser/getOperationParameter.ts +++ b/src/openApi/v3/parser/getOperationParameter.ts @@ -23,7 +23,7 @@ export const getOperationParameter = (openApi: OpenApi, parameter: OpenApiParame deprecated: parameter.deprecated === true, isDefinition: false, isReadOnly: false, - isRequired: parameter.required === true, + isRequired: parameter.required, isNullable: parameter.nullable === true, imports: [], enum: [], diff --git a/src/openApi/v3/parser/getOperationResponse.ts b/src/openApi/v3/parser/getOperationResponse.ts index dff19ec13..dbd65c36c 100644 --- a/src/openApi/v3/parser/getOperationResponse.ts +++ b/src/openApi/v3/parser/getOperationResponse.ts @@ -11,7 +11,7 @@ import { getType } from './getType'; export const getOperationResponse = ( openApi: OpenApi, response: OpenApiResponse, - responseCode: number + responseCode: number, ): OperationResponse => { const operationResponse: OperationResponse = { in: 'response', diff --git a/src/openApi/v3/parser/getRef.spec.ts b/src/openApi/v3/parser/getRef.spec.ts index 4195e55bc..f5cc45e05 100644 --- a/src/openApi/v3/parser/getRef.spec.ts +++ b/src/openApi/v3/parser/getRef.spec.ts @@ -27,8 +27,8 @@ describe('getRef', () => { }, { $ref: '#/components/schemas/Example', - } - ) + }, + ), ).toEqual({ description: 'This is an Example model ', type: 'integer', @@ -52,8 +52,8 @@ describe('getRef', () => { }, { $ref: '#/paths/~1api~1user~1%7Bid%7D', - } - ) + }, + ), ).toEqual({ description: 'This is an Example path', }); diff --git a/src/openApi/v3/parser/getRef.ts b/src/openApi/v3/parser/getRef.ts index 2c42690ee..708981cdb 100644 --- a/src/openApi/v3/parser/getRef.ts +++ b/src/openApi/v3/parser/getRef.ts @@ -18,7 +18,7 @@ export const getRef = (openApi: OpenApi, item: T & OpenApiReference): T => { let result: any = openApi; paths.forEach(path => { const decodedPath = decodeURIComponent( - path.replace(ESCAPED_REF_SLASH, '/').replace(ESCAPED_REF_TILDE, '~') + path.replace(ESCAPED_REF_SLASH, '/').replace(ESCAPED_REF_TILDE, '~'), ); if (result.hasOwnProperty(decodedPath)) { result = result[decodedPath]; diff --git a/src/openApi/v3/parser/getRequiredPropertiesFromComposition.ts b/src/openApi/v3/parser/getRequiredPropertiesFromComposition.ts index 0b1f1859f..5d38968a9 100644 --- a/src/openApi/v3/parser/getRequiredPropertiesFromComposition.ts +++ b/src/openApi/v3/parser/getRequiredPropertiesFromComposition.ts @@ -11,7 +11,7 @@ export const getRequiredPropertiesFromComposition = ( openApi: OpenApi, required: string[], definitions: OpenApiSchema[], - getModel: GetModelFn + getModel: GetModelFn, ): Model[] => { return definitions .reduce((properties, definition) => { diff --git a/src/openApi/v3/parser/getServer.spec.ts b/src/openApi/v3/parser/getServer.spec.ts index 46a1cc0b0..4f7027b08 100644 --- a/src/openApi/v3/parser/getServer.spec.ts +++ b/src/openApi/v3/parser/getServer.spec.ts @@ -15,7 +15,7 @@ describe('getServer', () => { url: 'https://localhost:8080/api', }, ], - }) + }), ).toEqual('https://localhost:8080/api'); }); @@ -41,7 +41,7 @@ describe('getServer', () => { }, }, ], - }) + }), ).toEqual('https://localhost:8080/api'); }); }); diff --git a/src/templates/core/angular/getRequestBody.hbs b/src/templates/core/angular/getRequestBody.hbs index 8af9c4226..2b9bb4875 100644 --- a/src/templates/core/angular/getRequestBody.hbs +++ b/src/templates/core/angular/getRequestBody.hbs @@ -1,12 +1,4 @@ -const getRequestBody = (options: ApiRequestOptions): any => { - if (options.body) { - if (options.mediaType?.includes('/json')) { - return JSON.stringify(options.body) - } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) { - return options.body; - } else { - return JSON.stringify(options.body); - } - } - return undefined; -}; +const getRequestBody = (options: ApiRequestOptions): any => { if (options.body) { if +(options.mediaType?.includes('/json')) { return JSON.stringify(options.body) } else if (isString(options.body) || +isBlob(options.body) || isFormData(options.body)) { return options.body; } else { return JSON.stringify(options.body); } +} return undefined; }; \ No newline at end of file diff --git a/src/templates/core/axios/getRequestBody.hbs b/src/templates/core/axios/getRequestBody.hbs index 78abe5dfa..ddad20d5e 100644 --- a/src/templates/core/axios/getRequestBody.hbs +++ b/src/templates/core/axios/getRequestBody.hbs @@ -1,6 +1,2 @@ -const getRequestBody = (options: ApiRequestOptions): any => { - if (options.body) { - return options.body; - } - return undefined; -}; +const getRequestBody = (options: ApiRequestOptions): any => { if (options.body) { return options.body; } return +undefined; }; \ No newline at end of file diff --git a/src/templates/core/fetch/getRequestBody.hbs b/src/templates/core/fetch/getRequestBody.hbs index b2fc7e21c..b865d35b9 100644 --- a/src/templates/core/fetch/getRequestBody.hbs +++ b/src/templates/core/fetch/getRequestBody.hbs @@ -1,12 +1,4 @@ -const getRequestBody = (options: ApiRequestOptions): any => { - if (options.body !== undefined) { - if (options.mediaType?.includes('/json')) { - return JSON.stringify(options.body) - } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) { - return options.body; - } else { - return JSON.stringify(options.body); - } - } - return undefined; -}; +const getRequestBody = (options: ApiRequestOptions): any => { if (options.body !== undefined) { if +(options.mediaType?.includes('/json')) { return JSON.stringify(options.body) } else if (isString(options.body) || +isBlob(options.body) || isFormData(options.body)) { return options.body; } else { return JSON.stringify(options.body); } +} return undefined; }; \ No newline at end of file diff --git a/src/templates/core/fetch/getResponseHeader.hbs b/src/templates/core/fetch/getResponseHeader.hbs index 531fb84f1..c08d7653d 100644 --- a/src/templates/core/fetch/getResponseHeader.hbs +++ b/src/templates/core/fetch/getResponseHeader.hbs @@ -1,9 +1,2 @@ -const getResponseHeader = (response: Response, responseHeader?: string): string | undefined => { - if (responseHeader) { - const content = response.headers.get(responseHeader); - if (isString(content)) { - return content; - } - } - return undefined; -}; +const getResponseHeader = (response: Response, responseHeader?: string): string | undefined => { if (responseHeader) { +const content = response.headers.get(responseHeader); if (isString(content)) { return content; } } return undefined; }; \ No newline at end of file diff --git a/src/templates/core/functions/base64.hbs b/src/templates/core/functions/base64.hbs index be275b851..007c7e7f3 100644 --- a/src/templates/core/functions/base64.hbs +++ b/src/templates/core/functions/base64.hbs @@ -1,8 +1,2 @@ -const base64 = (str: string): string => { - try { - return btoa(str); - } catch (err) { - // @ts-ignore - return Buffer.from(str).toString('base64'); - } -}; +const base64 = (str: string): string => { try { return btoa(str); } catch (err) { // @ts-ignore return +Buffer.from(str).toString('base64'); } }; \ No newline at end of file diff --git a/src/templates/core/functions/getFormData.hbs b/src/templates/core/functions/getFormData.hbs index 3a74b8f3a..12406d48e 100644 --- a/src/templates/core/functions/getFormData.hbs +++ b/src/templates/core/functions/getFormData.hbs @@ -1,26 +1,5 @@ -const getFormData = (options: ApiRequestOptions): FormData | undefined => { - if (options.formData) { - const formData = new FormData(); - - const process = (key: string, value: any) => { - if (isString(value) || isBlob(value)) { - formData.append(key, value); - } else { - formData.append(key, JSON.stringify(value)); - } - }; - - Object.entries(options.formData) - .filter(([_, value]) => isDefined(value)) - .forEach(([key, value]) => { - if (Array.isArray(value)) { - value.forEach(v => process(key, v)); - } else { - process(key, value); - } - }); - - return formData; - } - return undefined; -}; +const getFormData = (options: ApiRequestOptions): FormData | undefined => { if (options.formData) { const formData = new +FormData(); const process = (key: string, value: any) => { if (isString(value) || isBlob(value)) { formData.append(key, +value); } else { formData.append(key, JSON.stringify(value)); } }; Object.entries(options.formData) .filter(([_, value]) +=> isDefined(value)) .forEach(([key, value]) => { if (Array.isArray(value)) { value.forEach(v => process(key, v)); } +else { process(key, value); } }); return formData; } return undefined; }; \ No newline at end of file diff --git a/src/templates/core/functions/getUrl.hbs b/src/templates/core/functions/getUrl.hbs index fe181ab2e..2a60f7c5e 100644 --- a/src/templates/core/functions/getUrl.hbs +++ b/src/templates/core/functions/getUrl.hbs @@ -1,18 +1,5 @@ -const getUrl = (config: OpenAPIConfig, options: ApiRequestOptions): string => { - const encoder = config.ENCODE_PATH || encodeURI; - - const path = options.url - .replace('{api-version}', config.VERSION) - .replace(/{(.*?)}/g, (substring: string, group: string) => { - if (options.path?.hasOwnProperty(group)) { - return encoder(String(options.path[group])); - } - return substring; - }); - - const url = `${config.BASE}${path}`; - if (options.query) { - return `${url}${getQueryString(options.query)}`; - } - return url; -}; +const getUrl = (config: OpenAPIConfig, options: ApiRequestOptions): string => { const encoder = config.ENCODE_PATH || +encodeURI; const path = options.url .replace('{api-version}', config.VERSION) .replace(/{(.*?)}/g, (substring: string, +group: string) => { if (options.path?.hasOwnProperty(group)) { return encoder(String(options.path[group])); } return +substring; }); const url = `${config.BASE}${path}`; if (options.query) { return +`${url}${getQueryString(options.query)}`; } return url; }; \ No newline at end of file diff --git a/src/templates/core/functions/isBlob.hbs b/src/templates/core/functions/isBlob.hbs index caf44ddda..fcb468a0a 100644 --- a/src/templates/core/functions/isBlob.hbs +++ b/src/templates/core/functions/isBlob.hbs @@ -1,12 +1,4 @@ -const isBlob = (value: any): value is Blob => { - return ( - typeof value === 'object' && - typeof value.type === 'string' && - typeof value.stream === 'function' && - typeof value.arrayBuffer === 'function' && - typeof value.constructor === 'function' && - typeof value.constructor.name === 'string' && - /^(Blob|File)$/.test(value.constructor.name) && - /^(Blob|File)$/.test(value[Symbol.toStringTag]) - ); -}; +const isBlob = (value: any): value is Blob => { return ( typeof value === 'object' && typeof value.type === 'string' && +typeof value.stream === 'function' && typeof value.arrayBuffer === 'function' && typeof value.constructor === 'function' +&& typeof value.constructor.name === 'string' && /^(Blob|File)$/.test(value.constructor.name) && +/^(Blob|File)$/.test(value[Symbol.toStringTag]) ); }; \ No newline at end of file diff --git a/src/templates/core/functions/isFormData.hbs b/src/templates/core/functions/isFormData.hbs index 8bcbed6b4..dd5555859 100644 --- a/src/templates/core/functions/isFormData.hbs +++ b/src/templates/core/functions/isFormData.hbs @@ -1,3 +1 @@ -const isFormData = (value: any): value is FormData => { - return value instanceof FormData; -}; +const isFormData = (value: any): value is FormData => { return value instanceof FormData; }; \ No newline at end of file diff --git a/src/templates/core/functions/isString.hbs b/src/templates/core/functions/isString.hbs index b9888d56b..1c1e2e1a5 100644 --- a/src/templates/core/functions/isString.hbs +++ b/src/templates/core/functions/isString.hbs @@ -1,3 +1 @@ -const isString = (value: any): value is string => { - return typeof value === 'string'; -}; +const isString = (value: any): value is string => { return typeof value === 'string'; }; \ No newline at end of file diff --git a/src/templates/core/functions/isStringWithValue.hbs b/src/templates/core/functions/isStringWithValue.hbs index b1659067c..6d90d6419 100644 --- a/src/templates/core/functions/isStringWithValue.hbs +++ b/src/templates/core/functions/isStringWithValue.hbs @@ -1,3 +1 @@ -const isStringWithValue = (value: any): value is string => { - return isString(value) && value !== ''; -}; +const isStringWithValue = (value: any): value is string => { return isString(value) && value !== ''; }; \ No newline at end of file diff --git a/src/templates/core/functions/isSuccess.hbs b/src/templates/core/functions/isSuccess.hbs index 318af1241..b101a644e 100644 --- a/src/templates/core/functions/isSuccess.hbs +++ b/src/templates/core/functions/isSuccess.hbs @@ -1,3 +1 @@ -const isSuccess = (status: number): boolean => { - return status >= 200 && status < 300; -}; +const isSuccess = (status: number): boolean => { return status >= 200 && status \ No newline at end of file diff --git a/src/templates/core/node/getRequestBody.hbs b/src/templates/core/node/getRequestBody.hbs index d04d210cd..6138ec373 100644 --- a/src/templates/core/node/getRequestBody.hbs +++ b/src/templates/core/node/getRequestBody.hbs @@ -1,12 +1,4 @@ -const getRequestBody = (options: ApiRequestOptions): any => { - if (options.body !== undefined) { - if (options.mediaType?.includes('/json')) { - return JSON.stringify(options.body) - } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) { - return options.body as any; - } else { - return JSON.stringify(options.body); - } - } - return undefined; -}; +const getRequestBody = (options: ApiRequestOptions): any => { if (options.body !== undefined) { if +(options.mediaType?.includes('/json')) { return JSON.stringify(options.body) } else if (isString(options.body) || +isBlob(options.body) || isFormData(options.body)) { return options.body as any; } else { return +JSON.stringify(options.body); } } return undefined; }; \ No newline at end of file diff --git a/src/templates/core/node/getResponseHeader.hbs b/src/templates/core/node/getResponseHeader.hbs index 531fb84f1..c08d7653d 100644 --- a/src/templates/core/node/getResponseHeader.hbs +++ b/src/templates/core/node/getResponseHeader.hbs @@ -1,9 +1,2 @@ -const getResponseHeader = (response: Response, responseHeader?: string): string | undefined => { - if (responseHeader) { - const content = response.headers.get(responseHeader); - if (isString(content)) { - return content; - } - } - return undefined; -}; +const getResponseHeader = (response: Response, responseHeader?: string): string | undefined => { if (responseHeader) { +const content = response.headers.get(responseHeader); if (isString(content)) { return content; } } return undefined; }; \ No newline at end of file diff --git a/src/templates/core/xhr/getRequestBody.hbs b/src/templates/core/xhr/getRequestBody.hbs index b2fc7e21c..b865d35b9 100644 --- a/src/templates/core/xhr/getRequestBody.hbs +++ b/src/templates/core/xhr/getRequestBody.hbs @@ -1,12 +1,4 @@ -const getRequestBody = (options: ApiRequestOptions): any => { - if (options.body !== undefined) { - if (options.mediaType?.includes('/json')) { - return JSON.stringify(options.body) - } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) { - return options.body; - } else { - return JSON.stringify(options.body); - } - } - return undefined; -}; +const getRequestBody = (options: ApiRequestOptions): any => { if (options.body !== undefined) { if +(options.mediaType?.includes('/json')) { return JSON.stringify(options.body) } else if (isString(options.body) || +isBlob(options.body) || isFormData(options.body)) { return options.body; } else { return JSON.stringify(options.body); } +} return undefined; }; \ No newline at end of file diff --git a/src/templates/core/xhr/getResponseBody.hbs b/src/templates/core/xhr/getResponseBody.hbs index 84a662ef7..342ffe4a2 100644 --- a/src/templates/core/xhr/getResponseBody.hbs +++ b/src/templates/core/xhr/getResponseBody.hbs @@ -1,19 +1,5 @@ -const getResponseBody = (xhr: XMLHttpRequest): any => { - if (xhr.status !== 204) { - try { - const contentType = xhr.getResponseHeader('Content-Type'); - if (contentType) { - const jsonTypes = ['application/json', 'application/problem+json'] - const isJSON = jsonTypes.some(type => contentType.toLowerCase().startsWith(type)); - if (isJSON) { - return JSON.parse(xhr.responseText); - } else { - return xhr.responseText; - } - } - } catch (error) { - console.error(error); - } - } - return undefined; -}; +const getResponseBody = (xhr: XMLHttpRequest): any => { if (xhr.status !== 204) { try { const contentType = +xhr.getResponseHeader('Content-Type'); if (contentType) { const jsonTypes = ['application/json', +'application/problem+json'] const isJSON = jsonTypes.some(type => contentType.toLowerCase().startsWith(type)); if +(isJSON) { return JSON.parse(xhr.responseText); } else { return xhr.responseText; } } } catch (error) { +console.error(error); } } return undefined; }; \ No newline at end of file diff --git a/src/templates/core/xhr/getResponseHeader.hbs b/src/templates/core/xhr/getResponseHeader.hbs index b117d09dd..2bfe27ea6 100644 --- a/src/templates/core/xhr/getResponseHeader.hbs +++ b/src/templates/core/xhr/getResponseHeader.hbs @@ -1,9 +1,2 @@ -const getResponseHeader = (xhr: XMLHttpRequest, responseHeader?: string): string | undefined => { - if (responseHeader) { - const content = xhr.getResponseHeader(responseHeader); - if (isString(content)) { - return content; - } - } - return undefined; -}; +const getResponseHeader = (xhr: XMLHttpRequest, responseHeader?: string): string | undefined => { if (responseHeader) { +const content = xhr.getResponseHeader(responseHeader); if (isString(content)) { return content; } } return undefined; }; \ No newline at end of file diff --git a/src/templates/exportService.hbs b/src/templates/exportService.hbs index d6bccbbeb..5b0383b64 100644 --- a/src/templates/exportService.hbs +++ b/src/templates/exportService.hbs @@ -1,151 +1,94 @@ {{>header}} -{{#equals @root.httpClient 'angular'}} -{{#if @root.exportClient}} -import { Injectable } from '@angular/core'; -import type { Observable } from 'rxjs'; -{{else}} -import { Injectable } from '@angular/core'; -import { HttpClient } from '@angular/common/http'; -import type { Observable } from 'rxjs'; -{{/if}} - -{{/equals}} {{#if imports}} {{#each imports}} -import type { {{{this}}} } from '../models/{{{this}}}'; +import type { {{{this}}} } from 'sdk/src/api/models/Interfaces/GluonInterfaces/{{{this}}}'; {{/each}} - {{/if}} -{{#notEquals @root.httpClient 'angular'}} -import type { CancelablePromise } from '../core/CancelablePromise'; -{{/notEquals}} -{{#if @root.exportClient}} -{{#equals @root.httpClient 'angular'}} -import { BaseHttpRequest } from '../core/BaseHttpRequest'; -{{else}} -import type { BaseHttpRequest } from '../core/BaseHttpRequest'; -{{/equals}} -{{else}} -import { OpenAPI } from '../core/OpenAPI'; -import { request as __request } from '../core/request'; -{{/if}} - -{{#equals @root.httpClient 'angular'}} -@Injectable({ - providedIn: 'root', -}) -{{/equals}} -export class {{{name}}}{{{@root.postfix}}} { - {{#if @root.exportClient}} - constructor(public readonly httpRequest: BaseHttpRequest) {} - {{else}} - {{#equals @root.httpClient 'angular'}} +import { ErrorResult } from 'sdk/src/api/models/Interfaces/Repository/ErrorResult'; +import { BaseResult } from 'sdk/src/api/models/Interfaces/Repository/BaseResult'; +import { catchError } from 'sdk/src/api/core/ApiError'; +import { request as __request } from 'sdk/src/api/core/request'; +import { AuthHandler } from 'sdk/src/utilities/classes/AuthHandler'; - constructor(public readonly http: HttpClient) {} - {{/equals}} - {{/if}} - - {{#each operations}} +{{#each operations}} /** - {{#if deprecated}} - * @deprecated - {{/if}} - {{#if summary}} - * {{{escapeComment summary}}} - {{/if}} - {{#if description}} - * {{{escapeComment description}}} - {{/if}} - {{#unless @root.useOptions}} {{#if parameters}} {{#each parameters}} - * @param {{{name}}} {{#if description}}{{{escapeComment description}}}{{/if}} + {{#if name}} + {{#notEquals name 'userId'}} + * @param { {{{type}}} } {{{name}}} {{#if description}}{{{escapeComment description}}}{{/if}} + {{/notEquals}} + {{/if}} {{/each}} {{/if}} - {{/unless}} + */ + export interface {{capitalizeFirst name}}Params { + {{#each parameters}} + {{#if name}} + {{#notEquals name 'userId'}} + {{#if isRequired}} + {{{name}}}: {{type}}; + {{else}} + {{{name}}}?: {{type}}; + {{/if}} + {{/notEquals}} + {{/if}} + {{/each}} + } + +{{/each}} + +export class {{{name}}}{{{@root.postfix}}} { + private userId: string; + constructor() { + this.userId = AuthHandler.userId; + } + + {{#each operations}} + /** + * @param { {{{name}}}Params } object {{#each results}} * @returns {{{type}}} {{#if description}}{{{escapeComment description}}}{{/if}} {{/each}} * @throws ApiError */ - {{#if @root.exportClient}} - {{#equals @root.httpClient 'angular'}} - public {{{name}}}({{>parameters}}): Observable<{{>result}}> { - return this.httpRequest.request({ - {{else}} - public {{{name}}}({{>parameters}}): CancelablePromise<{{>result}}> { - return this.httpRequest.request({ - {{/equals}} - {{else}} - {{#equals @root.httpClient 'angular'}} - public {{{name}}}({{>parameters}}): Observable<{{>result}}> { - return __request(OpenAPI, this.http, { - {{else}} - public static {{{name}}}({{>parameters}}): CancelablePromise<{{>result}}> { - return __request(OpenAPI, { - {{/equals}} - {{/if}} - method: '{{{method}}}', - url: '{{{path}}}', - {{#if parametersPath}} - path: { - {{#each parametersPath}} - '{{{prop}}}': {{{name}}}, - {{/each}} - }, - {{/if}} - {{#if parametersCookie}} - cookies: { - {{#each parametersCookie}} - '{{{prop}}}': {{{name}}}, - {{/each}} - }, - {{/if}} - {{#if parametersHeader}} - headers: { - {{#each parametersHeader}} - '{{{prop}}}': {{{name}}}, - {{/each}} - }, + + public async {{{name}}}({ + {{#each parameters}} + {{#if name}} + {{#notEquals name 'userId'}} + {{#if default}} + {{{name}}} = {{{default}}}, + {{else}} + {{{name}}}, + {{/if}} + {{/notEquals}} {{/if}} + {{/each}} + } : {{capitalizeFirst name}}Params ): Promiseresult}} | ErrorResult>> { + const result = await __request({ + method: '{{{method}}}', + path: `{{#replace "userId" "this.userId"}}{{#replace "{" "${"}}{{{path}}}{{/replace}}{{/replace}}`, {{#if parametersQuery}} query: { {{#each parametersQuery}} - '{{{prop}}}': {{{name}}}, - {{/each}} - }, - {{/if}} - {{#if parametersForm}} - formData: { - {{#each parametersForm}} - '{{{prop}}}': {{{name}}}, + '{{{prop}}}': {{#replace "userId" "this.userId"}}{{{name}}}{{/replace}}, {{/each}} }, {{/if}} {{#if parametersBody}} - {{#equals parametersBody.in 'formData'}} - formData: {{{parametersBody.name}}}, - {{/equals}} {{#equals parametersBody.in 'body'}} body: {{{parametersBody.name}}}, {{/equals}} - {{#if parametersBody.mediaType}} - mediaType: '{{{parametersBody.mediaType}}}', - {{/if}} - {{/if}} - {{#if responseHeader}} - responseHeader: '{{{responseHeader}}}', - {{/if}} - {{#if errors}} - errors: { - {{#each errors}} - {{{code}}}: `{{{escapeDescription description}}}`, - {{/each}} - }, {{/if}} }); + + if (!result.ok) { + catchError(result as BaseResult); + } + return result as BaseResult<{{>result}}>; } {{/each}} diff --git a/src/templates/index.hbs b/src/templates/index.hbs index 6f5b27d8c..86cad2bc4 100644 --- a/src/templates/index.hbs +++ b/src/templates/index.hbs @@ -9,8 +9,11 @@ export { ApiError } from './core/ApiError'; {{#if @root.exportClient}} export { BaseHttpRequest } from './core/BaseHttpRequest'; {{/if}} -export { CancelablePromise, CancelError } from './core/CancelablePromise'; +{{!-- export { CancelablePromise, CancelError } from './core/CancelablePromise'; --}} export { OpenAPI } from './core/OpenAPI'; +export { IBaseResult } from './core/IBaseResult'; +export { IErrorResult } from './core/IErrorResult'; +export { IParam } from './core/IParam'; export type { OpenAPIConfig } from './core/OpenAPI'; {{/if}} {{#if @root.exportModels}} @@ -18,13 +21,13 @@ export type { OpenAPIConfig } from './core/OpenAPI'; {{#each models}} {{#if @root.useUnionTypes}} -export type { {{{name}}}{{#if @root.postfixModels}} as {{{name}}}{{{@root.postfixModels}}}{{/if}} } from './models/{{{name}}}'; +export type { {{{name}}}{{#if @root.postfixModels}} as {{{name}}}{{{@root.postfixModels}}}{{/if}} } from 'sdk/src/api/models/Interfaces/GluonInterfaces/{{{name}}}'; {{else if enum}} -export { {{{name}}}{{#if @root.postfixModels}} as {{{name}}}{{{@root.postfixModels}}}{{/if}} } from './models/{{{name}}}'; +export { {{{name}}}{{#if @root.postfixModels}} as {{{name}}}{{{@root.postfixModels}}}{{/if}} } from 'sdk/src/api/models/Interfaces/GluonInterfaces/{{{name}}}'; {{else if enums}} -export { {{{name}}}{{#if @root.postfixModels}} as {{{name}}}{{{@root.postfixModels}}}{{/if}} } from './models/{{{name}}}'; +export { {{{name}}}{{#if @root.postfixModels}} as {{{name}}}{{{@root.postfixModels}}}{{/if}} } from 'sdk/src/api/models/Interfaces/GluonInterfaces/{{{name}}}'; {{else}} -export type { {{{name}}}{{#if @root.postfixModels}} as {{{name}}}{{{@root.postfixModels}}}{{/if}} } from './models/{{{name}}}'; +export type { {{{name}}}{{#if @root.postfixModels}} as {{{name}}}{{{@root.postfixModels}}}{{/if}} } from 'sdk/src/api/models/Interfaces/GluonInterfaces/{{{name}}}'; {{/if}} {{/each}} {{/if}} @@ -41,7 +44,7 @@ export { ${{{name}}} } from './schemas/${{{name}}}'; {{#if services}} {{#each services}} -export { {{{name}}}{{{@root.postfixServices}}} } from './services/{{{name}}}{{{@root.postfixServices}}}'; +export { {{{name}}}{{{@root.postfixServices}}} } from 'sdk/src/api/services/Gluon_services/{{{name}}}{{{@root.postfixServices}}}'; {{/each}} {{/if}} {{/if}} diff --git a/src/templates/partials/base.hbs b/src/templates/partials/base.hbs index 1799e7d2a..06632dad9 100644 --- a/src/templates/partials/base.hbs +++ b/src/templates/partials/base.hbs @@ -1,9 +1,9 @@ {{~#equals base 'binary'~}} -{{~#equals @root.httpClient 'fetch'}}Blob{{/equals~}} -{{~#equals @root.httpClient 'xhr'}}Blob{{/equals~}} -{{~#equals @root.httpClient 'axios'}}Blob{{/equals~}} -{{~#equals @root.httpClient 'angular'}}Blob{{/equals~}} -{{~#equals @root.httpClient 'node'}}Blob{{/equals~}} + {{~#equals @root.httpClient 'fetch'}}Blob{{/equals~}} + {{~#equals @root.httpClient 'xhr'}}Blob{{/equals~}} + {{~#equals @root.httpClient 'axios'}}Blob{{/equals~}} + {{~#equals @root.httpClient 'angular'}}Blob{{/equals~}} + {{~#equals @root.httpClient 'node'}}Blob{{/equals~}} {{~else~}} -{{{base}}} -{{~/equals~}} + {{{base}}} +{{~/equals~}} \ No newline at end of file diff --git a/src/templates/partials/exportEnum.hbs b/src/templates/partials/exportEnum.hbs index f47622ef9..0e4d04d4d 100644 --- a/src/templates/partials/exportEnum.hbs +++ b/src/templates/partials/exportEnum.hbs @@ -1,24 +1,30 @@ {{#ifdef description deprecated}} -/** -{{#if description}} - * {{{escapeComment description}}} -{{/if}} -{{#if deprecated}} - * @deprecated -{{/if}} - */ + /** + {{#if description}} + * + {{{escapeComment description}}} + {{/if}} + {{#if deprecated}} + * @deprecated + {{/if}} + */ {{/ifdef}} -export enum {{{name}}} { - {{#each enum}} - {{#if description}} - /** - * {{{escapeComment description}}} - */ - {{/if}} - {{#containsSpaces name}} - '{{{name}}}' = {{{value}}}, - {{else}} - {{{name}}} = {{{value}}}, - {{/containsSpaces}} - {{/each}} -} +export enum +{{{name}}} +{ +{{#each enum}} + {{#if description}} + /** * + {{{escapeComment description}}} + */ + {{/if}} + {{#containsSpaces name}} + '{{{name}}}' = + {{{value}}}, + {{else}} + {{{name}}} + = + {{{value}}}, + {{/containsSpaces}} +{{/each}} +} \ No newline at end of file diff --git a/src/templates/partials/exportInterface.hbs b/src/templates/partials/exportInterface.hbs index b61e26441..9c298a1e0 100644 --- a/src/templates/partials/exportInterface.hbs +++ b/src/templates/partials/exportInterface.hbs @@ -8,7 +8,8 @@ {{/if}} */ {{/ifdef}} -export type {{{name}}} = { +{{#if_eq name }} +export interface {{{name}}} { {{#each properties}} {{#ifdef description deprecated}} /** @@ -20,14 +21,30 @@ export type {{{name}}} = { {{/if}} */ {{/ifdef}} - {{>isReadOnly}}{{{name}}}{{>isRequired}}: {{>type parent=../name}}; + {{{name}}}{{>isRequired}}: {{>type parent=../name}}; {{/each}} }; +{{else}} +export interface {{{name}}} { + {{#each properties}} + {{#ifdef description deprecated}} + /** + {{#if description}} + * {{{escapeComment description}}} + {{/if}} + {{#if deprecated}} + * @deprecated + {{/if}} + */ + {{/ifdef}} + readonly {{{name}}}{{>isRequired}}: {{>type parent=../name}}; + {{/each}} +}; +{{/if_eq}} {{#if enums}} {{#unless @root.useUnionTypes}} export namespace {{{name}}} { - {{#each enums}} {{#if description}} /** @@ -39,9 +56,7 @@ export namespace {{{name}}} { {{{name}}} = {{{value}}}, {{/each}} } - {{/each}} - } {{/unless}} {{/if}} diff --git a/src/templates/partials/header.hbs b/src/templates/partials/header.hbs index d592379e7..56564e6d3 100644 --- a/src/templates/partials/header.hbs +++ b/src/templates/partials/header.hbs @@ -1,3 +1 @@ -/* istanbul ignore file */ -/* tslint:disable */ -/* eslint-disable */ +/* istanbul ignore file */ /* tslint:disable */ /* eslint-disable */ \ No newline at end of file diff --git a/src/templates/partials/isNullable.hbs b/src/templates/partials/isNullable.hbs index 7ef73e3d0..05a34064b 100644 --- a/src/templates/partials/isNullable.hbs +++ b/src/templates/partials/isNullable.hbs @@ -1 +1 @@ -{{#if isNullable}} | null{{/if}} +{{#if isNullable}} | null{{/if}} \ No newline at end of file diff --git a/src/templates/partials/isReadOnly.hbs b/src/templates/partials/isReadOnly.hbs index 7ab3bdbf6..2154ff375 100644 --- a/src/templates/partials/isReadOnly.hbs +++ b/src/templates/partials/isReadOnly.hbs @@ -1 +1 @@ -{{#if isReadOnly}}readonly {{/if}} +{{#if isReadOnly}}readonly {{/if}} \ No newline at end of file diff --git a/src/templates/partials/isRequired.hbs b/src/templates/partials/isRequired.hbs index b829272b9..4da6eec0b 100644 --- a/src/templates/partials/isRequired.hbs +++ b/src/templates/partials/isRequired.hbs @@ -1,5 +1,5 @@ {{~#if @root.useOptions~}} -{{#unless isRequired}}?{{else if default}}?{{/unless}} + {{#unless isRequired}}?{{else}}{{#if default}}?{{/if}}{{/unless}} {{~else~}} -{{#unless isRequired}}{{#unless default}}?{{/unless}}{{/unless}} -{{~/if~}} + {{#unless isRequired}}{{#unless default}}?{{/unless}}{{/unless}} +{{~/if~}} \ No newline at end of file diff --git a/src/templates/partials/schemaEnum.hbs b/src/templates/partials/schemaEnum.hbs index eaba3fc5f..7901aad68 100644 --- a/src/templates/partials/schemaEnum.hbs +++ b/src/templates/partials/schemaEnum.hbs @@ -1,12 +1,14 @@ -{ - type: 'Enum', +{ type: 'Enum', {{#if isReadOnly}} - isReadOnly: {{{isReadOnly}}}, + isReadOnly: + {{{isReadOnly}}}, {{/if}} {{#if isRequired}} - isRequired: {{{isRequired}}}, + isRequired: + {{{isRequired}}}, {{/if}} {{#if isNullable}} - isNullable: {{{isNullable}}}, + isNullable: + {{{isNullable}}}, {{/if}} -} +} \ No newline at end of file diff --git a/src/templates/partials/schemaGeneric.hbs b/src/templates/partials/schemaGeneric.hbs index 23580a673..839d17b40 100644 --- a/src/templates/partials/schemaGeneric.hbs +++ b/src/templates/partials/schemaGeneric.hbs @@ -1,59 +1,74 @@ { {{#if type}} - type: '{{{type}}}', + type: '{{{type}}}', {{/if}} {{#if description}} - description: `{{{escapeDescription description}}}`, + description: `{{{escapeDescription description}}}`, {{/if}} {{#if isReadOnly}} - isReadOnly: {{{isReadOnly}}}, + isReadOnly: + {{{isReadOnly}}}, {{/if}} {{#if isRequired}} - isRequired: {{{isRequired}}}, + isRequired: + {{{isRequired}}}, {{/if}} {{#if isNullable}} - isNullable: {{{isNullable}}}, + isNullable: + {{{isNullable}}}, {{/if}} {{#if format}} - format: '{{{format}}}', + format: '{{{format}}}', {{/if}} {{#if maximum}} - maximum: {{{maximum}}}, + maximum: + {{{maximum}}}, {{/if}} {{#if exclusiveMaximum}} - exclusiveMaximum: {{{exclusiveMaximum}}}, + exclusiveMaximum: + {{{exclusiveMaximum}}}, {{/if}} {{#if minimum}} - minimum: {{{minimum}}}, + minimum: + {{{minimum}}}, {{/if}} {{#if exclusiveMinimum}} - exclusiveMinimum: {{{exclusiveMinimum}}}, + exclusiveMinimum: + {{{exclusiveMinimum}}}, {{/if}} {{#if multipleOf}} - multipleOf: {{{multipleOf}}}, + multipleOf: + {{{multipleOf}}}, {{/if}} {{#if maxLength}} - maxLength: {{{maxLength}}}, + maxLength: + {{{maxLength}}}, {{/if}} {{#if minLength}} - minLength: {{{minLength}}}, + minLength: + {{{minLength}}}, {{/if}} {{#if pattern}} - pattern: '{{{pattern}}}', + pattern: '{{{pattern}}}', {{/if}} {{#if maxItems}} - maxItems: {{{maxItems}}}, + maxItems: + {{{maxItems}}}, {{/if}} {{#if minItems}} - minItems: {{{minItems}}}, + minItems: + {{{minItems}}}, {{/if}} {{#if uniqueItems}} - uniqueItems: {{{uniqueItems}}}, + uniqueItems: + {{{uniqueItems}}}, {{/if}} {{#if maxProperties}} - maxProperties: {{{maxProperties}}}, + maxProperties: + {{{maxProperties}}}, {{/if}} {{#if minProperties}} - minProperties: {{{minProperties}}}, + minProperties: + {{{minProperties}}}, {{/if}} -} +} \ No newline at end of file diff --git a/src/utils/registerHandlebarHelpers.ts b/src/utils/registerHandlebarHelpers.ts index 88f47c19b..e8c5ea9e9 100644 --- a/src/utils/registerHandlebarHelpers.ts +++ b/src/utils/registerHandlebarHelpers.ts @@ -20,25 +20,55 @@ export const registerHandlebarHelpers = (root: { return options.inverse(this); }); + Handlebars.registerHelper('replace', function (this: any, find: string, replace: string, options) { + var string = options.fn(this) as string; + let re = new RegExp(find, 'g'); + return string.replace(re, replace); + }); + + Handlebars.registerHelper('log', function (this: any, content) { + console.log(content.fn(this)); + return ''; + }); + + Handlebars.registerHelper('if_eq', function (this: any, a, options) { + let string = a as string; + if (string.includes('Request')) return options.fn(this); + else return options.inverse(this); + }); + + Handlebars.registerHelper('deleteUserId', function (this: any, options) { + let string = options.fn(this) as string; + let re = new RegExp('userId: string,', 'g'); + return string.replace(re, ''); + }); + + Handlebars.registerHelper( + 'capitalizeFirst', + function (this: any, a: string, options: Handlebars.HelperOptions): string { + return a.charAt(0).toUpperCase() + a.slice(1); + }, + ); + Handlebars.registerHelper( 'equals', function (this: any, a: string, b: string, options: Handlebars.HelperOptions): string { return a === b ? options.fn(this) : options.inverse(this); - } + }, ); Handlebars.registerHelper( 'notEquals', function (this: any, a: string, b: string, options: Handlebars.HelperOptions): string { return a !== b ? options.fn(this) : options.inverse(this); - } + }, ); Handlebars.registerHelper( 'containsSpaces', function (this: any, value: string, options: Handlebars.HelperOptions): string { return /\s+/.test(value) ? options.fn(this) : options.inverse(this); - } + }, ); Handlebars.registerHelper( @@ -52,7 +82,7 @@ export const registerHandlebarHelpers = (root: { uniqueTypesString = `(${uniqueTypesString})`; } return options.fn(uniqueTypesString); - } + }, ); Handlebars.registerHelper( @@ -66,7 +96,7 @@ export const registerHandlebarHelpers = (root: { uniqueTypesString = `(${uniqueTypesString})`; } return options.fn(uniqueTypesString); - } + }, ); Handlebars.registerHelper( @@ -76,7 +106,7 @@ export const registerHandlebarHelpers = (root: { enumerators: Enum[], parent: string | undefined, name: string | undefined, - options: Handlebars.HelperOptions + options: Handlebars.HelperOptions, ) { if (!root.useUnionTypes && parent && name) { return `${parent}.${name}`; @@ -85,9 +115,9 @@ export const registerHandlebarHelpers = (root: { enumerators .map(enumerator => enumerator.value) .filter(unique) - .join(' | ') + .join(' | '), ); - } + }, ); Handlebars.registerHelper('escapeComment', function (value: string): string { diff --git a/src/utils/writeClient.spec.ts b/src/utils/writeClient.spec.ts index 3c06a95a5..ca50cc596 100644 --- a/src/utils/writeClient.spec.ts +++ b/src/utils/writeClient.spec.ts @@ -49,7 +49,7 @@ describe('writeClient', () => { true, Indent.SPACE_4, 'Service', - 'AppClient' + 'AppClient', ); expect(rmdir).toBeCalled(); diff --git a/src/utils/writeClient.ts b/src/utils/writeClient.ts index cea2f3d88..dfa4a84fe 100644 --- a/src/utils/writeClient.ts +++ b/src/utils/writeClient.ts @@ -48,13 +48,13 @@ export const writeClient = async ( postfixServices: string, postfixModels: string, clientName?: string, - request?: string + request?: string, ): Promise => { const outputPath = resolve(process.cwd(), output); const outputPathCore = resolve(outputPath, 'core'); - const outputPathModels = resolve(outputPath, 'models'); + const outputPathModels = resolve(outputPath, 'models/Interfaces/GluonInterfaces'); const outputPathSchemas = resolve(outputPath, 'schemas'); - const outputPathServices = resolve(outputPath, 'services'); + const outputPathServices = resolve(outputPath, 'services/Gluon_services'); if (!isSubDirectory(process.cwd(), output)) { throw new Error(`Output folder is not a subdirectory of the current working directory`); @@ -78,7 +78,7 @@ export const writeClient = async ( useOptions, indent, postfixServices, - clientName + clientName, ); } @@ -112,7 +112,7 @@ export const writeClient = async ( exportSchemas, postfixServices, postfixModels, - clientName + clientName, ); } }; diff --git a/src/utils/writeClientClass.ts b/src/utils/writeClientClass.ts index 558150bb4..c5bf64246 100644 --- a/src/utils/writeClientClass.ts +++ b/src/utils/writeClientClass.ts @@ -30,7 +30,7 @@ export const writeClientClass = async ( httpClient: HttpClient, clientName: string, indent: Indent, - postfix: string + postfix: string, ): Promise => { const templateResult = templates.client({ clientName, diff --git a/src/utils/writeClientCore.ts b/src/utils/writeClientCore.ts index 6d35849d2..75a23d42f 100644 --- a/src/utils/writeClientCore.ts +++ b/src/utils/writeClientCore.ts @@ -26,7 +26,7 @@ export const writeClientCore = async ( httpClient: HttpClient, indent: Indent, clientName?: string, - request?: string + request?: string, ): Promise => { const httpRequest = getHttpRequestName(httpClient); const context = { diff --git a/src/utils/writeClientIndex.ts b/src/utils/writeClientIndex.ts index 5044294d5..ce4882f1f 100644 --- a/src/utils/writeClientIndex.ts +++ b/src/utils/writeClientIndex.ts @@ -34,7 +34,7 @@ export const writeClientIndex = async ( exportSchemas: boolean, postfixServices: string, postfixModels: string, - clientName?: string + clientName?: string, ): Promise => { const templateResult = templates.index({ exportCore, diff --git a/src/utils/writeClientModels.ts b/src/utils/writeClientModels.ts index 997569b9f..f58306d47 100644 --- a/src/utils/writeClientModels.ts +++ b/src/utils/writeClientModels.ts @@ -23,7 +23,7 @@ export const writeClientModels = async ( outputPath: string, httpClient: HttpClient, useUnionTypes: boolean, - indent: Indent + indent: Indent, ): Promise => { for (const model of models) { const file = resolve(outputPath, `${model.name}.ts`); diff --git a/src/utils/writeClientSchemas.ts b/src/utils/writeClientSchemas.ts index e1c885f64..065f6f218 100644 --- a/src/utils/writeClientSchemas.ts +++ b/src/utils/writeClientSchemas.ts @@ -23,7 +23,7 @@ export const writeClientSchemas = async ( outputPath: string, httpClient: HttpClient, useUnionTypes: boolean, - indent: Indent + indent: Indent, ): Promise => { for (const model of models) { const file = resolve(outputPath, `$${model.name}.ts`); diff --git a/src/utils/writeClientServices.ts b/src/utils/writeClientServices.ts index 2f95341d2..5cba3f368 100644 --- a/src/utils/writeClientServices.ts +++ b/src/utils/writeClientServices.ts @@ -30,7 +30,7 @@ export const writeClientServices = async ( useOptions: boolean, indent: Indent, postfix: string, - clientName?: string + clientName?: string, ): Promise => { for (const service of services) { const file = resolve(outputPath, `${service.name}${postfix}.ts`); diff --git a/test/e2e/assets/index.html b/test/e2e/assets/index.html index ff6dd5554..a4eb8b170 100644 --- a/test/e2e/assets/index.html +++ b/test/e2e/assets/index.html @@ -1,10 +1,9 @@ - - - - - - - + + + + + + diff --git a/test/e2e/assets/main-angular-module.ts b/test/e2e/assets/main-angular-module.ts index f6529550e..bb6c9f610 100644 --- a/test/e2e/assets/main-angular-module.ts +++ b/test/e2e/assets/main-angular-module.ts @@ -41,7 +41,7 @@ export class AppComponent { private readonly parametersService: ParametersService, private readonly responseService: ResponseService, private readonly simpleService: SimpleService, - private readonly typesService: TypesService + private readonly typesService: TypesService, ) { (window as any).api = { OpenAPI, diff --git a/test/e2e/assets/main-angular.ts b/test/e2e/assets/main-angular.ts index 1ed564d2f..667f2b7c6 100644 --- a/test/e2e/assets/main-angular.ts +++ b/test/e2e/assets/main-angular.ts @@ -40,7 +40,7 @@ export class AppComponent { private readonly parametersService: ParametersService, private readonly responseService: ResponseService, private readonly simpleService: SimpleService, - private readonly typesService: TypesService + private readonly typesService: TypesService, ) { (window as any).api = { OpenAPI, diff --git a/test/e2e/client.angular.spec.ts b/test/e2e/client.angular.spec.ts index ef8deee80..5a62bb5be 100644 --- a/test/e2e/client.angular.spec.ts +++ b/test/e2e/client.angular.spec.ts @@ -77,7 +77,7 @@ describe('client.angular', () => { 'valuePath', { prop: 'valueBody', - } + }, ).subscribe(resolve); }); }); @@ -98,7 +98,7 @@ describe('client.angular', () => { status: e.status, statusText: e.statusText, body: e.body, - }) + }), ); }, }); @@ -115,7 +115,7 @@ describe('client.angular', () => { status: 500, message: 'hello world', }, - }) + }), ); }); @@ -133,7 +133,7 @@ describe('client.angular', () => { status: e.status, statusText: e.statusText, body: e.body, - }) + }), ); }, }); @@ -150,7 +150,7 @@ describe('client.angular', () => { status: 409, message: 'hello world', }, - }) + }), ); }); }); diff --git a/test/e2e/client.axios.spec.ts b/test/e2e/client.axios.spec.ts index ed8952b68..bdabc89e7 100644 --- a/test/e2e/client.axios.spec.ts +++ b/test/e2e/client.axios.spec.ts @@ -63,7 +63,7 @@ describe('client.axios', () => { 'valuePath', { prop: 'valueBody', - } + }, ); expect(result).toBeDefined(); }); @@ -112,7 +112,7 @@ describe('client.axios', () => { status: 500, message: 'hello world', }, - }) + }), ); }); @@ -144,7 +144,7 @@ describe('client.axios', () => { status: 409, message: 'hello world', }, - }) + }), ); }); }); diff --git a/test/e2e/client.babel.spec.ts b/test/e2e/client.babel.spec.ts index 7fe79d0ba..7e8f5e487 100644 --- a/test/e2e/client.babel.spec.ts +++ b/test/e2e/client.babel.spec.ts @@ -133,7 +133,7 @@ describe('client.babel', () => { status: 500, message: 'hello world', }, - }) + }), ); }); @@ -169,7 +169,7 @@ describe('client.babel', () => { status: 409, message: 'hello world', }, - }) + }), ); }); }); diff --git a/test/e2e/client.fetch.spec.ts b/test/e2e/client.fetch.spec.ts index 3a1844384..a2b39a247 100644 --- a/test/e2e/client.fetch.spec.ts +++ b/test/e2e/client.fetch.spec.ts @@ -75,7 +75,7 @@ describe('client.fetch', () => { 'valuePath', { prop: 'valueBody', - } + }, ); }); expect(result).toBeDefined(); @@ -130,7 +130,7 @@ describe('client.fetch', () => { status: 500, message: 'hello world', }, - }) + }), ); }); @@ -164,7 +164,7 @@ describe('client.fetch', () => { status: 409, message: 'hello world', }, - }) + }), ); }); }); diff --git a/test/e2e/client.node.spec.ts b/test/e2e/client.node.spec.ts index 9967cf019..2b7eaafd1 100644 --- a/test/e2e/client.node.spec.ts +++ b/test/e2e/client.node.spec.ts @@ -63,7 +63,7 @@ describe('client.node', () => { 'valuePath', { prop: 'valueBody', - } + }, ); expect(result).toBeDefined(); }); @@ -112,7 +112,7 @@ describe('client.node', () => { status: 500, message: 'hello world', }, - }) + }), ); }); @@ -144,7 +144,7 @@ describe('client.node', () => { status: 409, message: 'hello world', }, - }) + }), ); }); }); diff --git a/test/e2e/client.xhr.spec.ts b/test/e2e/client.xhr.spec.ts index 487fb0145..25e2846fe 100644 --- a/test/e2e/client.xhr.spec.ts +++ b/test/e2e/client.xhr.spec.ts @@ -75,7 +75,7 @@ describe('client.xhr', () => { 'valuePath', { prop: 'valueBody', - } + }, ); }); expect(result).toBeDefined(); @@ -129,7 +129,7 @@ describe('client.xhr', () => { status: 500, message: 'hello world', }, - }) + }), ); }); @@ -163,7 +163,7 @@ describe('client.xhr', () => { status: 409, message: 'hello world', }, - }) + }), ); }); }); diff --git a/test/e2e/scripts/buildAngularProject.ts b/test/e2e/scripts/buildAngularProject.ts index 43060756b..dc16bf146 100644 --- a/test/e2e/scripts/buildAngularProject.ts +++ b/test/e2e/scripts/buildAngularProject.ts @@ -19,6 +19,6 @@ export const buildAngularProject = (dir: string, name: string, output: string) = { cwd: resolvePath(cwd), stdio: 'inherit', - } + }, ); }; diff --git a/test/e2e/scripts/compileWithTypescript.ts b/test/e2e/scripts/compileWithTypescript.ts index 4a8ab1de5..0fac7cb31 100644 --- a/test/e2e/scripts/compileWithTypescript.ts +++ b/test/e2e/scripts/compileWithTypescript.ts @@ -39,7 +39,7 @@ export const compileWithTypescript = (dir: string) => { sys, resolve(process.cwd(), cwd), undefined, - 'tsconfig.json' + 'tsconfig.json', ); const compilerHost = createCompilerHost(configFileResult.options); const compiler = createProgram(configFileResult.fileNames, configFileResult.options, compilerHost); diff --git a/test/e2e/scripts/createAngularProject.ts b/test/e2e/scripts/createAngularProject.ts index 2b51ed361..601e178ad 100644 --- a/test/e2e/scripts/createAngularProject.ts +++ b/test/e2e/scripts/createAngularProject.ts @@ -35,7 +35,7 @@ export const createAngularProject = (dir: string, name: string) => { { cwd: resolvePath(cwd), stdio: 'inherit', - } + }, ); rmSync(`${cwd}/${name}/src/app/`, { recursive: true, diff --git a/test/e2e/scripts/generateClient.ts b/test/e2e/scripts/generateClient.ts index 9c0402528..7eefb7a5b 100644 --- a/test/e2e/scripts/generateClient.ts +++ b/test/e2e/scripts/generateClient.ts @@ -6,7 +6,7 @@ export const generateClient = async ( client: 'fetch' | 'xhr' | 'node' | 'axios' | 'angular', useOptions: boolean = false, useUnionTypes: boolean = false, - clientName?: string + clientName?: string, ) => { await __generate({ input: `./test/spec/${version}.json`, diff --git a/test/e2e/scripts/server.ts b/test/e2e/scripts/server.ts index 37a41907d..91574ca24 100644 --- a/test/e2e/scripts/server.ts +++ b/test/e2e/scripts/server.ts @@ -17,7 +17,7 @@ const start = async (dir: string) => { express.static(`./test/e2e/generated/${dir}/`, { extensions: ['', 'js'], index: 'index.js', - }) + }), ); _app.use( @@ -25,7 +25,7 @@ const start = async (dir: string) => { express.static(`./test/e2e/generated/${dir}/`, { extensions: ['', 'js'], index: 'index.js', - }) + }), ); // Serve static assets diff --git a/test/e2e/v3.angular.spec.ts b/test/e2e/v3.angular.spec.ts index 2b039fe71..18c6ec779 100644 --- a/test/e2e/v3.angular.spec.ts +++ b/test/e2e/v3.angular.spec.ts @@ -77,7 +77,7 @@ describe('v3.angular', () => { 'valuePath', { prop: 'valueBody', - } + }, ).subscribe(resolve); }); }); @@ -115,7 +115,7 @@ describe('v3.angular', () => { status: 500, message: 'hello world', }, - }) + }), ); }); @@ -152,7 +152,7 @@ describe('v3.angular', () => { status: 409, message: 'hello world', }, - }) + }), ); }); }); diff --git a/test/e2e/v3.axios.spec.ts b/test/e2e/v3.axios.spec.ts index b43b0a54b..a2da64607 100644 --- a/test/e2e/v3.axios.spec.ts +++ b/test/e2e/v3.axios.spec.ts @@ -57,7 +57,7 @@ describe('v3.axios', () => { 'valuePath', { prop: 'valueBody', - } + }, ); expect(result).toBeDefined(); }); @@ -104,7 +104,7 @@ describe('v3.axios', () => { status: 500, message: 'hello world', }, - }) + }), ); }); @@ -135,7 +135,7 @@ describe('v3.axios', () => { status: 409, message: 'hello world', }, - }) + }), ); }); diff --git a/test/e2e/v3.babel.spec.ts b/test/e2e/v3.babel.spec.ts index 42463b4ba..7bfe56d45 100644 --- a/test/e2e/v3.babel.spec.ts +++ b/test/e2e/v3.babel.spec.ts @@ -126,7 +126,7 @@ describe('v3.babel', () => { status: 500, message: 'hello world', }, - }) + }), ); }); @@ -161,7 +161,7 @@ describe('v3.babel', () => { status: 409, message: 'hello world', }, - }) + }), ); }); diff --git a/test/e2e/v3.fetch.spec.ts b/test/e2e/v3.fetch.spec.ts index 2fb58d1e2..62b501074 100644 --- a/test/e2e/v3.fetch.spec.ts +++ b/test/e2e/v3.fetch.spec.ts @@ -69,7 +69,7 @@ describe('v3.fetch', () => { 'valuePath', { prop: 'valueBody', - } + }, ); }); expect(result).toBeDefined(); @@ -122,7 +122,7 @@ describe('v3.fetch', () => { status: 500, message: 'hello world', }, - }) + }), ); }); @@ -155,7 +155,7 @@ describe('v3.fetch', () => { status: 409, message: 'hello world', }, - }) + }), ); }); diff --git a/test/e2e/v3.node.spec.ts b/test/e2e/v3.node.spec.ts index 5dd4ec346..7a019fc50 100644 --- a/test/e2e/v3.node.spec.ts +++ b/test/e2e/v3.node.spec.ts @@ -57,7 +57,7 @@ describe('v3.node', () => { 'valuePath', { prop: 'valueBody', - } + }, ); expect(result).toBeDefined(); }); @@ -104,7 +104,7 @@ describe('v3.node', () => { status: 500, message: 'hello world', }, - }) + }), ); }); @@ -135,7 +135,7 @@ describe('v3.node', () => { status: 409, message: 'hello world', }, - }) + }), ); }); diff --git a/test/e2e/v3.xhr.spec.ts b/test/e2e/v3.xhr.spec.ts index a117027ad..520cc550a 100644 --- a/test/e2e/v3.xhr.spec.ts +++ b/test/e2e/v3.xhr.spec.ts @@ -69,7 +69,7 @@ describe('v3.xhr', () => { 'valuePath', { prop: 'valueBody', - } + }, ); }); expect(result).toBeDefined(); @@ -121,7 +121,7 @@ describe('v3.xhr', () => { status: 500, message: 'hello world', }, - }) + }), ); }); @@ -154,7 +154,7 @@ describe('v3.xhr', () => { status: 409, message: 'hello world', }, - }) + }), ); }); diff --git a/test/spec/v2.json b/test/spec/v2.json index e8eb19b51..8aefa6aa7 100644 --- a/test/spec/v2.json +++ b/test/spec/v2.json @@ -6,9 +6,7 @@ }, "host": "localhost:3000", "basePath": "/base", - "schemes": [ - "http" - ], + "schemes": ["http"], "paths": { "/api/v{api-version}/no-tag": { "tags": [], @@ -18,53 +16,37 @@ }, "/api/v{api-version}/simple": { "get": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "GetCallWithoutParametersAndResponse" }, "put": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "PutCallWithoutParametersAndResponse" }, "post": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "PostCallWithoutParametersAndResponse" }, "delete": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "DeleteCallWithoutParametersAndResponse" }, "options": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "OptionsCallWithoutParametersAndResponse" }, "head": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "HeadCallWithoutParametersAndResponse" }, "patch": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "PatchCallWithoutParametersAndResponse" } }, "/api/v{api-version}/descriptions/": { "post": { - "tags": [ - "Descriptions" - ], + "tags": ["Descriptions"], "operationId": "CallWithDescriptions", "parameters": [ { @@ -108,9 +90,7 @@ }, "/api/v{api-version}/parameters/{parameterPath}": { "post": { - "tags": [ - "Parameters" - ], + "tags": ["Parameters"], "operationId": "CallWithParameters", "parameters": [ { @@ -159,9 +139,7 @@ }, "/api/v{api-version}/parameters/{parameter.path.1}/{parameter-path-2}/{PARAMETER-PATH-3}": { "post": { - "tags": [ - "Parameters" - ], + "tags": ["Parameters"], "operationId": "CallWithWeirdParameterNames", "parameters": [ { @@ -231,9 +209,7 @@ }, "/api/v{api-version}/defaults": { "get": { - "tags": [ - "Defaults" - ], + "tags": ["Defaults"], "operationId": "CallWithDefaultParameters", "parameters": [ { @@ -267,11 +243,7 @@ "required": true, "default": 0, "schema": { - "enum": [ - "Success", - "Warning", - "Error" - ] + "enum": ["Success", "Warning", "Error"] } }, { @@ -289,9 +261,7 @@ ] }, "post": { - "tags": [ - "Defaults" - ], + "tags": ["Defaults"], "operationId": "CallWithDefaultOptionalParameters", "parameters": [ { @@ -321,11 +291,7 @@ "in": "query", "default": 0, "schema": { - "enum": [ - "Success", - "Warning", - "Error" - ] + "enum": ["Success", "Warning", "Error"] } }, { @@ -342,9 +308,7 @@ ] }, "put": { - "tags": [ - "Defaults" - ], + "tags": ["Defaults"], "operationId": "CallToTestOrderOfParams", "parameters": [ { @@ -415,39 +379,25 @@ }, "/api/v{api-version}/duplicate": { "get": { - "tags": [ - "Duplicate", - "Duplicate" - ], + "tags": ["Duplicate", "Duplicate"], "operationId": "DuplicateName" }, "post": { - "tags": [ - "Duplicate", - "Duplicate" - ], + "tags": ["Duplicate", "Duplicate"], "operationId": "DuplicateName" }, "put": { - "tags": [ - "Duplicate", - "Duplicate" - ], + "tags": ["Duplicate", "Duplicate"], "operationId": "DuplicateName" }, "delete": { - "tags": [ - "Duplicate", - "Duplicate" - ], + "tags": ["Duplicate", "Duplicate"], "operationId": "DuplicateName" } }, "/api/v{api-version}/no-content": { "get": { - "tags": [ - "NoContent" - ], + "tags": ["NoContent"], "operationId": "CallWithNoContentResponse", "responses": { "204": { @@ -458,10 +408,7 @@ }, "/api/v{api-version}/multiple-tags/a": { "get": { - "tags": [ - "MultipleTags1", - "MultipleTags2" - ], + "tags": ["MultipleTags1", "MultipleTags2"], "operationId": "DummyA", "responses": { "204": { @@ -472,11 +419,7 @@ }, "/api/v{api-version}/multiple-tags/b": { "get": { - "tags": [ - "MultipleTags1", - "MultipleTags2", - "MultipleTags3" - ], + "tags": ["MultipleTags1", "MultipleTags2", "MultipleTags3"], "operationId": "DummyB", "responses": { "204": { @@ -487,9 +430,7 @@ }, "/api/v{api-version}/response": { "get": { - "tags": [ - "Response" - ], + "tags": ["Response"], "operationId": "CallWithResponse", "responses": { "default": { @@ -501,9 +442,7 @@ } }, "post": { - "tags": [ - "Response" - ], + "tags": ["Response"], "operationId": "CallWithDuplicateResponses", "responses": { "default": { @@ -545,9 +484,7 @@ } }, "put": { - "tags": [ - "Response" - ], + "tags": ["Response"], "operationId": "CallWithResponses", "responses": { "default": { @@ -614,9 +551,7 @@ }, "/api/v{api-version}/collectionFormat": { "get": { - "tags": [ - "CollectionFormat" - ], + "tags": ["CollectionFormat"], "operationId": "CollectionFormat", "parameters": [ { @@ -679,9 +614,7 @@ }, "/api/v{api-version}/types": { "get": { - "tags": [ - "Types" - ], + "tags": ["Types"], "operationId": "Types", "parameters": [ { @@ -742,11 +675,7 @@ "in": "query", "required": true, "schema": { - "enum": [ - "Success", - "Warning", - "Error" - ] + "enum": ["Success", "Warning", "Error"] } }, { @@ -790,9 +719,7 @@ }, "/api/v{api-version}/complex": { "get": { - "tags": [ - "Complex" - ], + "tags": ["Complex"], "operationId": "ComplexTypes", "parameters": [ { @@ -850,9 +777,7 @@ }, "/api/v{api-version}/header": { "post": { - "tags": [ - "Header" - ], + "tags": ["Header"], "operationId": "CallWithResultFromHeader", "responses": { "200": { @@ -874,9 +799,7 @@ }, "/api/v{api-version}/error": { "post": { - "tags": [ - "Error" - ], + "tags": ["Error"], "operationId": "testErrorCode", "parameters": [ { @@ -960,33 +883,11 @@ }, "EnumWithStrings": { "description": "This is a simple enum with strings", - "enum": [ - "Success", - "Warning", - "Error", - "'Single Quote'", - "\"Double Quotes\"" - ] + "enum": ["Success", "Warning", "Error", "'Single Quote'", "\"Double Quotes\""] }, "EnumWithNumbers": { "description": "This is a simple enum with numbers", - "enum": [ - 1, - 2, - 3, - 1.1, - 1.20, - 1.300, - 100, - 200, - 300, - -100, - -200, - -300, - -1.1, - -1.20, - -1.300 - ] + "enum": [1, 2, 3, 1.1, 1.2, 1.3, 100, 200, 300, -100, -200, -300, -1.1, -1.2, -1.3] }, "EnumFromDescription": { "description": "Success=1,Warning=2,Error=3", @@ -994,16 +895,8 @@ }, "EnumWithExtensions": { "description": "This is a simple enum with numbers", - "enum": [ - 200, - 400, - 500 - ], - "x-enum-varnames": [ - "CUSTOM_SUCCESS", - "CUSTOM_WARNING", - "CUSTOM_ERROR" - ], + "enum": [200, 400, 500], + "x-enum-varnames": ["CUSTOM_SUCCESS", "CUSTOM_WARNING", "CUSTOM_ERROR"], "x-enum-descriptions": [ "Used when the status of something is successful", "Used when the status of something has a warning", @@ -1149,9 +1042,7 @@ "ModelWithNullableString": { "description": "This is a model with one string property", "type": "object", - "required": [ - "nullableRequiredProp" - ], + "required": ["nullableRequiredProp"], "properties": { "nullableProp": { "description": "This is a simple string property", @@ -1171,29 +1062,16 @@ "properties": { "test": { "description": "This is a simple enum with strings", - "enum": [ - "Success", - "Warning", - "Error" - ] + "enum": ["Success", "Warning", "Error"] }, "statusCode": { "description": "These are the HTTP error code enums", - "enum": [ - "100", - "200 FOO", - "300 FOO_BAR", - "400 foo-bar", - "500 foo.bar", - "600 foo&bar" - ] + "enum": ["100", "200 FOO", "300 FOO_BAR", "400 foo-bar", "500 foo.bar", "600 foo&bar"] }, "bool": { "description": "Simple boolean enum", "type": "boolean", - "enum": [ - true - ] + "enum": [true] } } }, @@ -1214,11 +1092,7 @@ "dictionaryWithEnum": { "type": "object", "additionalProperties": { - "enum": [ - "Success", - "Warning", - "Error" - ] + "enum": ["Success", "Warning", "Error"] } }, "dictionaryWithEnumFromDescription": { @@ -1231,11 +1105,7 @@ "arrayWithEnum": { "type": "array", "items": { - "enum": [ - "Success", - "Warning", - "Error" - ] + "enum": ["Success", "Warning", "Error"] } }, "arrayWithDescription": { @@ -1304,10 +1174,7 @@ "ModelWithProperties": { "description": "This is a model with one nested property", "type": "object", - "required": [ - "required", - "requiredAndReadOnly" - ], + "required": ["required", "requiredAndReadOnly"], "properties": { "required": { "type": "string" @@ -1350,22 +1217,16 @@ "ModelWithNestedProperties": { "description": "This is a model with one nested property", "type": "object", - "required": [ - "first" - ], + "required": ["first"], "properties": { "first": { "type": "object", - "required": [ - "second" - ], + "required": ["second"], "readOnly": true, "properties": { "second": { "type": "object", - "required": [ - "third" - ], + "required": ["third"], "readOnly": true, "properties": { "third": { @@ -1477,10 +1338,7 @@ "ModelWithPattern": { "description": "This is a model that contains a some patterns", "type": "object", - "required": [ - "key", - "name" - ], + "required": ["key", "name"], "properties": { "key": { "maxLength": 64, diff --git a/test/spec/v3.json b/test/spec/v3.json index cb590d0b7..356d2c3a2 100644 --- a/test/spec/v3.json +++ b/test/spec/v3.json @@ -18,53 +18,37 @@ }, "/api/v{api-version}/simple": { "get": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "GetCallWithoutParametersAndResponse" }, "put": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "PutCallWithoutParametersAndResponse" }, "post": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "PostCallWithoutParametersAndResponse" }, "delete": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "DeleteCallWithoutParametersAndResponse" }, "options": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "OptionsCallWithoutParametersAndResponse" }, "head": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "HeadCallWithoutParametersAndResponse" }, "patch": { - "tags": [ - "Simple" - ], + "tags": ["Simple"], "operationId": "PatchCallWithoutParametersAndResponse" } }, "/api/v{api-version}/descriptions/": { "post": { - "tags": [ - "Descriptions" - ], + "tags": ["Descriptions"], "operationId": "CallWithDescriptions", "parameters": [ { @@ -108,9 +92,7 @@ }, "/api/v{api-version}/parameters/deprecated": { "post": { - "tags": [ - "Deprecated" - ], + "tags": ["Deprecated"], "deprecated": true, "operationId": "DeprecatedCall", "parameters": [ @@ -130,9 +112,7 @@ }, "/api/v{api-version}/parameters/{parameterPath}": { "post": { - "tags": [ - "Parameters" - ], + "tags": ["Parameters"], "operationId": "CallWithParameters", "parameters": [ { @@ -211,9 +191,7 @@ }, "/api/v{api-version}/parameters/{parameter.path.1}/{parameter-path-2}/{PARAMETER-PATH-3}": { "post": { - "tags": [ - "Parameters" - ], + "tags": ["Parameters"], "operationId": "CallWithWeirdParameterNames", "parameters": [ { @@ -322,9 +300,7 @@ }, "/api/v{api-version}/parameters/": { "get": { - "tags": [ - "Parameters" - ], + "tags": ["Parameters"], "operationId": "GetCallWithOptionalParam", "parameters": [ { @@ -350,9 +326,7 @@ } }, "post": { - "tags": [ - "Parameters" - ], + "tags": ["Parameters"], "operationId": "PostCallWithOptionalParam", "parameters": [ { @@ -380,9 +354,7 @@ }, "/api/v{api-version}/requestBody/": { "post": { - "tags": [ - "RequestBody" - ], + "tags": ["RequestBody"], "parameters": [ { "$ref": "#/components/parameters/SimpleParameter" @@ -395,9 +367,7 @@ }, "/api/v{api-version}/formData/": { "post": { - "tags": [ - "FormData" - ], + "tags": ["FormData"], "parameters": [ { "$ref": "#/components/parameters/SimpleParameter" @@ -410,9 +380,7 @@ }, "/api/v{api-version}/defaults": { "get": { - "tags": [ - "Defaults" - ], + "tags": ["Defaults"], "operationId": "CallWithDefaultParameters", "parameters": [ { @@ -450,11 +418,7 @@ "name": "parameterEnum", "in": "query", "schema": { - "enum": [ - "Success", - "Warning", - "Error" - ], + "enum": ["Success", "Warning", "Error"], "default": 0 } }, @@ -473,9 +437,7 @@ ] }, "post": { - "tags": [ - "Defaults" - ], + "tags": ["Defaults"], "operationId": "CallWithDefaultOptionalParameters", "parameters": [ { @@ -514,11 +476,7 @@ "in": "query", "required": false, "schema": { - "enum": [ - "Success", - "Warning", - "Error" - ], + "enum": ["Success", "Warning", "Error"], "default": 0 } }, @@ -537,9 +495,7 @@ ] }, "put": { - "tags": [ - "Defaults" - ], + "tags": ["Defaults"], "operationId": "CallToTestOrderOfParams", "parameters": [ { @@ -626,35 +582,25 @@ }, "/api/v{api-version}/duplicate": { "get": { - "tags": [ - "Duplicate" - ], + "tags": ["Duplicate"], "operationId": "DuplicateName" }, "post": { - "tags": [ - "Duplicate" - ], + "tags": ["Duplicate"], "operationId": "DuplicateName" }, "put": { - "tags": [ - "Duplicate" - ], + "tags": ["Duplicate"], "operationId": "DuplicateName" }, "delete": { - "tags": [ - "Duplicate" - ], + "tags": ["Duplicate"], "operationId": "DuplicateName" } }, "/api/v{api-version}/no-content": { "get": { - "tags": [ - "NoContent" - ], + "tags": ["NoContent"], "operationId": "CallWithNoContentResponse", "responses": { "204": { @@ -665,10 +611,7 @@ }, "/api/v{api-version}/multiple-tags/a": { "get": { - "tags": [ - "MultipleTags1", - "MultipleTags2" - ], + "tags": ["MultipleTags1", "MultipleTags2"], "operationId": "DummyA", "responses": { "204": { @@ -679,11 +622,7 @@ }, "/api/v{api-version}/multiple-tags/b": { "get": { - "tags": [ - "MultipleTags1", - "MultipleTags2", - "MultipleTags3" - ], + "tags": ["MultipleTags1", "MultipleTags2", "MultipleTags3"], "operationId": "DummyB", "responses": { "204": { @@ -694,9 +633,7 @@ }, "/api/v{api-version}/response": { "get": { - "tags": [ - "Response" - ], + "tags": ["Response"], "operationId": "CallWithResponse", "responses": { "default": { @@ -711,9 +648,7 @@ } }, "post": { - "tags": [ - "Response" - ], + "tags": ["Response"], "operationId": "CallWithDuplicateResponses", "responses": { "default": { @@ -779,9 +714,7 @@ } }, "put": { - "tags": [ - "Response" - ], + "tags": ["Response"], "operationId": "CallWithResponses", "responses": { "default": { @@ -876,9 +809,7 @@ }, "/api/v{api-version}/collectionFormat": { "get": { - "tags": [ - "CollectionFormat" - ], + "tags": ["CollectionFormat"], "operationId": "CollectionFormat", "parameters": [ { @@ -956,9 +887,7 @@ }, "/api/v{api-version}/types": { "get": { - "tags": [ - "Types" - ], + "tags": ["Types"], "operationId": "Types", "parameters": [ { @@ -1036,11 +965,7 @@ "in": "query", "required": true, "schema": { - "enum": [ - "Success", - "Warning", - "Error" - ], + "enum": ["Success", "Warning", "Error"], "nullable": true } }, @@ -1100,9 +1025,7 @@ }, "/api/v{api-version}/upload": { "post": { - "tags": [ - "Upload" - ], + "tags": ["Upload"], "operationId": "UploadFile", "parameters": [ { @@ -1139,9 +1062,7 @@ }, "/api/v{api-version}/complex": { "get": { - "tags": [ - "Complex" - ], + "tags": ["Complex"], "operationId": "ComplexTypes", "parameters": [ { @@ -1203,9 +1124,7 @@ }, "/api/v{api-version}/multipart": { "post": { - "tags": [ - "multipart" - ], + "tags": ["multipart"], "operationId": "MultipartRequest", "requestBody": { "content": { @@ -1240,9 +1159,7 @@ } }, "get": { - "tags": [ - "multipart" - ], + "tags": ["multipart"], "operationId": "MultipartResponse", "responses": { "200": { @@ -1277,9 +1194,7 @@ }, "/api/v{api-version}/complex/{id}": { "put": { - "tags": [ - "Complex" - ], + "tags": ["Complex"], "operationId": "ComplexParams", "parameters": [ { @@ -1304,12 +1219,7 @@ "content": { "application/json-patch+json": { "schema": { - "required": [ - "key", - "name", - "parameters", - "type" - ], + "required": ["key", "name", "parameters", "type"], "type": "object", "properties": { "key": { @@ -1329,11 +1239,7 @@ "default": true }, "type": { - "enum": [ - "Monkey", - "Horse", - "Bird" - ], + "enum": ["Monkey", "Horse", "Bird"], "type": "string", "readOnly": true }, @@ -1405,9 +1311,7 @@ }, "/api/v{api-version}/header": { "post": { - "tags": [ - "Header" - ], + "tags": ["Header"], "operationId": "CallWithResultFromHeader", "responses": { "200": { @@ -1431,9 +1335,7 @@ }, "/api/v{api-version}/error": { "post": { - "tags": [ - "Error" - ], + "tags": ["Error"], "operationId": "testErrorCode", "parameters": [ { @@ -1556,33 +1458,11 @@ }, "EnumWithStrings": { "description": "This is a simple enum with strings", - "enum": [ - "Success", - "Warning", - "Error", - "'Single Quote'", - "\"Double Quotes\"" - ] + "enum": ["Success", "Warning", "Error", "'Single Quote'", "\"Double Quotes\""] }, "EnumWithNumbers": { "description": "This is a simple enum with numbers", - "enum": [ - 1, - 2, - 3, - 1.1, - 1.20, - 1.300, - 100, - 200, - 300, - -100, - -200, - -300, - -1.1, - -1.20, - -1.300 - ] + "enum": [1, 2, 3, 1.1, 1.2, 1.3, 100, 200, 300, -100, -200, -300, -1.1, -1.2, -1.3] }, "EnumFromDescription": { "description": "Success=1,Warning=2,Error=3", @@ -1590,16 +1470,8 @@ }, "EnumWithExtensions": { "description": "This is a simple enum with numbers", - "enum": [ - 200, - 400, - 500 - ], - "x-enum-varnames": [ - "CUSTOM_SUCCESS", - "CUSTOM_WARNING", - "CUSTOM_ERROR" - ], + "enum": [200, 400, 500], + "x-enum-varnames": ["CUSTOM_SUCCESS", "CUSTOM_WARNING", "CUSTOM_ERROR"], "x-enum-descriptions": [ "Used when the status of something is successful", "Used when the status of something has a warning", @@ -1741,10 +1613,7 @@ "ModelWithNullableString": { "description": "This is a model with one string property", "type": "object", - "required": [ - "nullableRequiredProp1", - "nullableRequiredProp2" - ], + "required": ["nullableRequiredProp1", "nullableRequiredProp2"], "properties": { "nullableProp1": { "description": "This is a simple string property", @@ -1758,17 +1627,11 @@ }, "nullableProp2": { "description": "This is a simple string property", - "type": [ - "string", - "null" - ] + "type": ["string", "null"] }, "nullableRequiredProp2": { "description": "This is a simple string property", - "type": [ - "string", - "null" - ] + "type": ["string", "null"] } } }, @@ -1778,29 +1641,16 @@ "properties": { "test": { "description": "This is a simple enum with strings", - "enum": [ - "Success", - "Warning", - "Error" - ] + "enum": ["Success", "Warning", "Error"] }, "statusCode": { "description": "These are the HTTP error code enums", - "enum": [ - "100", - "200 FOO", - "300 FOO_BAR", - "400 foo-bar", - "500 foo.bar", - "600 foo&bar" - ] + "enum": ["100", "200 FOO", "300 FOO_BAR", "400 foo-bar", "500 foo.bar", "600 foo&bar"] }, "bool": { "description": "Simple boolean enum", "type": "boolean", - "enum": [ - true - ] + "enum": [true] } } }, @@ -1821,11 +1671,7 @@ "dictionaryWithEnum": { "type": "object", "additionalProperties": { - "enum": [ - "Success", - "Warning", - "Error" - ] + "enum": ["Success", "Warning", "Error"] } }, "dictionaryWithEnumFromDescription": { @@ -1838,11 +1684,7 @@ "arrayWithEnum": { "type": "array", "items": { - "enum": [ - "Success", - "Warning", - "Error" - ] + "enum": ["Success", "Warning", "Error"] } }, "arrayWithDescription": { @@ -1974,9 +1816,7 @@ "ModelCircle": { "description": "Circle", "type": "object", - "required": [ - "kind" - ], + "required": ["kind"], "properties": { "kind": { "type": "string" @@ -1989,9 +1829,7 @@ "ModelSquare": { "description": "Square", "type": "object", - "required": [ - "kind" - ], + "required": ["kind"], "properties": { "kind": { "type": "string" @@ -2253,20 +2091,12 @@ "type": "number" } }, - "required": [ - "firstName", - "lastname", - "age" - ] + "required": ["firstName", "lastname", "age"] }, "ModelWithProperties": { "description": "This is a model with one nested property", "type": "object", - "required": [ - "required", - "requiredAndReadOnly", - "requiredAndNullable" - ], + "required": ["required", "requiredAndReadOnly", "requiredAndNullable"], "properties": { "required": { "type": "string" @@ -2313,23 +2143,17 @@ "ModelWithNestedProperties": { "description": "This is a model with one nested property", "type": "object", - "required": [ - "first" - ], + "required": ["first"], "properties": { "first": { "type": "object", - "required": [ - "second" - ], + "required": ["second"], "readOnly": true, "nullable": true, "properties": { "second": { "type": "object", - "required": [ - "third" - ], + "required": ["third"], "readOnly": true, "nullable": true, "properties": { @@ -2436,10 +2260,7 @@ "ModelWithPattern": { "description": "This is a model that contains a some patterns", "type": "object", - "required": [ - "key", - "name" - ], + "required": ["key", "name"], "properties": { "key": { "maxLength": 64, @@ -2474,9 +2295,7 @@ } }, "File": { - "required": [ - "mime" - ], + "required": ["mime"], "type": "object", "properties": { "id": { diff --git a/tsconfig.json b/tsconfig.json index 8d27e49a8..2327d4379 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -18,16 +18,9 @@ "experimentalDecorators": true }, - "files": [ - "./src/typings/hbs.d.ts" - ], + "files": ["./src/typings/hbs.d.ts"], - "include": [ - "./src/**/*.ts" - ], + "include": ["./src/**/*.ts"], - "exclude": [ - "node_modules", - "**/__mocks__" - ] + "exclude": ["node_modules", "**/__mocks__"] }