From d86f2560ac69507fb3a5eaee4718e42ed5c4b682 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 25 Jul 2022 22:43:33 +0000 Subject: [PATCH 1/2] YOYO NEW API SPEC! --- spec.json | 5087 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 5079 insertions(+), 8 deletions(-) diff --git a/spec.json b/spec.json index 2eb3a102b..257dd32a6 100644 --- a/spec.json +++ b/spec.json @@ -3545,7 +3545,1678 @@ ], "type": "string" }, - "UnitConversion": { + "UnitAccelerationConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitAccelerationFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitAccelerationFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitAccelerationFormat": { + "description": "The valid types of metric unit formats.", + "enum": [ + "meters_per_second_squared", + "feet_per_second_squared", + "standard_gravity" + ], + "type": "string" + }, + "UnitAngleConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitAngleFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitAngleFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitAngleFormat": { + "description": "The valid types of angle formats.", + "enum": [ + "radian", + "degree", + "arcminute", + "arcsecond", + "milliarcsecond", + "turn", + "gradian" + ], + "type": "string" + }, + "UnitAngularVelocityConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitAngularVelocityFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitAngularVelocityFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitAngularVelocityFormat": { + "description": "The valid types of angular velocity unit formats.", + "enum": [ + "radians_per_second", + "degrees_per_second", + "revolutions_per_minute", + "milliarcseconds_per_year" + ], + "type": "string" + }, + "UnitAreaConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitAreaFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitAreaFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitAreaFormat": { + "description": "The valid types of area unit formats.", + "enum": [ + "square_meter", + "square_foot", + "square_inch", + "square_mile", + "square_kilometer", + "hectare", + "acre" + ], + "type": "string" + }, + "UnitChargeConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitChargeFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitChargeFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitChargeFormat": { + "description": "The valid types of charge unit formats.", + "enum": [ + "coulomb", + "ampere_hour" + ], + "type": "string" + }, + "UnitConcentrationConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitConcentrationFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitConcentrationFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitConcentrationFormat": { + "description": "The valid types of concentration unit formats.", + "enum": [ + "parts_per_million", + "parts_per_billion", + "parts_per_trillion", + "percent" + ], + "type": "string" + }, + "UnitDataConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitDataFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitDataFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitDataFormat": { + "description": "The valid types of data unit formats.", + "enum": [ + "byte", + "exabyte", + "bit", + "exabit" + ], + "type": "string" + }, + "UnitDataTransferRateConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitDataTransferRateFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitDataTransferRateFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitDataTransferRateFormat": { + "description": "The valid types of data transfer unit formats.", + "enum": [ + "bytes_per_second", + "exabytes_per_second", + "bits_per_second", + "exabits_per_second" + ], + "type": "string" + }, + "UnitDensityConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitDensityFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitDensityFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitDensityFormat": { + "description": "The valid types of density unit formats.", + "enum": [ + "kilograms_per_cubic_meter", + "grams_per_milliliter", + "kilograms_per_liter", + "ounces_per_cubic_foot", + "ounces_per_cubic_inch", + "ounces_per_gallon", + "pounds_per_cubic_foot", + "pounds_per_cubic_inch", + "pounds_per_gallon", + "slugs_per_cubic_foot" + ], + "type": "string" + }, + "UnitEnergyConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitEnergyFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitEnergyFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitEnergyFormat": { + "description": "The valid types of energy unit formats.", + "enum": [ + "joule", + "calorie", + "british_thermal_unit", + "british_thermal_unit_iso", + "british_thermal_unit59", + "foot_pound" + ], + "type": "string" + }, + "UnitForceConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitForceFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitForceFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitForceFormat": { + "description": "The valid types of force unit formats.", + "enum": [ + "newton", + "pound", + "dyne", + "kilopound", + "poundal" + ], + "type": "string" + }, + "UnitIlluminanceConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitIlluminanceFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitIlluminanceFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitIlluminanceFormat": { + "description": "The valid types of illuminance unit formats.", + "enum": [ + "lux", + "footcandle", + "lumens_per_square_inch", + "phot" + ], + "type": "string" + }, + "UnitLengthConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitLengthFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitLengthFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitLengthFormat": { + "description": "The valid types of length unit formats.", + "enum": [ + "meter", + "foot", + "inch", + "mile", + "nautical_mile", + "astronomical_unit", + "cubit", + "fathom", + "chain", + "furlong", + "hand", + "league", + "nautical_league", + "yard" + ], + "type": "string" + }, + "UnitMagneticFieldStrengthConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitMagneticFieldStrengthFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitMagneticFieldStrengthFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitMagneticFieldStrengthFormat": { + "description": "The valid types of magnetic field strength unit formats.", + "enum": [ + "tesla", + "gauss" + ], + "type": "string" + }, + "UnitMagneticFluxConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitMagneticFluxFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitMagneticFluxFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitMagneticFluxFormat": { + "description": "The valid types of magnetic flux unit formats.", + "enum": [ + "weber", + "maxwell" + ], + "type": "string" + }, + "UnitMassConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitMassFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitMassFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitMassFormat": { + "description": "The valid types of mass unit formats.", + "enum": [ + "gram", + "metric_ton", + "pound", + "long_ton", + "short_ton", + "stone", + "ounce", + "carat", + "slug" + ], + "type": "string" + }, + "UnitMetricConversion": { "description": "A unit conversion.", "properties": { "completed_at": { @@ -3661,6 +5332,939 @@ ], "type": "string" }, + "UnitPowerConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitPowerFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitPowerFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitPowerFormat": { + "description": "The valid types of power unit formats.", + "enum": [ + "watt", + "horsepower", + "milliwatt" + ], + "type": "string" + }, + "UnitPressureConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitPressureFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitPressureFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitPressureFormat": { + "description": "The valid types of pressure unit formats.", + "enum": [ + "pascal", + "bar", + "mbar", + "atmosphere", + "pounds_per_square_inch" + ], + "type": "string" + }, + "UnitRadiationConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitRadiationFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitRadiationFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitRadiationFormat": { + "description": "The valid types of radiation unit formats.", + "enum": [ + "gray", + "sievert", + "rad" + ], + "type": "string" + }, + "UnitSolidAngleConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitSolidAngleFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitSolidAngleFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitSolidAngleFormat": { + "description": "The valid types of solid angle unit formats.", + "enum": [ + "steradian", + "degree_squared", + "spat" + ], + "type": "string" + }, + "UnitTemperatureConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitTemperatureFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitTemperatureFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitTemperatureFormat": { + "description": "The valid types of temperature unit formats.", + "enum": [ + "kelvin", + "celsius", + "fahrenheit", + "reaumur", + "rankine" + ], + "type": "string" + }, + "UnitTimeConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitTimeFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitTimeFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitTimeFormat": { + "description": "The valid types of time unit formats.", + "enum": [ + "second", + "minute", + "hour", + "day", + "week", + "year", + "julian_year", + "gregorian_year" + ], + "type": "string" + }, + "UnitVelocityConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitVelocityFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitVelocityFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitVelocityFormat": { + "description": "The valid types of velocity unit formats.", + "enum": [ + "meters_per_second", + "feet_per_second", + "miles_per_hour", + "kilometers_per_hour", + "knot" + ], + "type": "string" + }, + "UnitVoltageConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitVoltageFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitVoltageFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitVoltageFormat": { + "description": "The valid types of voltage unit formats.", + "enum": [ + "volt", + "statvolt", + "abvolt" + ], + "type": "string" + }, + "UnitVolumeConversion": { + "description": "A unit conversion.", + "properties": { + "completed_at": { + "description": "The time and date the unit conversion was completed.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "created_at": { + "description": "The time and date the unit conversion was created.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "error": { + "description": "The error the function returned, if any.", + "nullable": true, + "type": "string" + }, + "id": { + "allOf": [ + { + "$ref": "#/components/schemas/Uuid" + } + ], + "description": "The unique identifier of the unit conversion.\n\nThis is the same as the API call ID." + }, + "input": { + "default": 0.0, + "description": "The input value.", + "format": "float", + "type": "number" + }, + "output": { + "description": "The resulting value.", + "format": "double", + "nullable": true, + "type": "number" + }, + "output_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitVolumeFormat" + } + ], + "description": "The output format of the unit conversion." + }, + "src_format": { + "allOf": [ + { + "$ref": "#/components/schemas/UnitVolumeFormat" + } + ], + "description": "The source format of the unit conversion." + }, + "started_at": { + "description": "The time and date the unit conversion was started.", + "format": "date-time", + "nullable": true, + "title": "DateTime", + "type": "string" + }, + "status": { + "allOf": [ + { + "$ref": "#/components/schemas/ApiCallStatus" + } + ], + "description": "The status of the unit conversion." + }, + "updated_at": { + "description": "The time and date the unit conversion was last updated.", + "format": "date-time", + "title": "DateTime", + "type": "string" + }, + "user_id": { + "description": "The user ID of the user who created the unit conversion.", + "type": "string" + } + }, + "required": [ + "created_at", + "id", + "output_format", + "src_format", + "status", + "updated_at" + ], + "type": "object" + }, + "UnitVolumeFormat": { + "description": "The valid types of volume unit formats.", + "enum": [ + "cubic_meter", + "cubic_millimeter", + "cubic_kilometer", + "liter", + "cubic_foot", + "cubic_yard", + "cubic_mile" + ], + "type": "string" + }, "UpdateUser": { "description": "The user-modifiable parts of a User.", "properties": { @@ -4345,6 +6949,73 @@ ] } }, + "/apps/github/webhook": { + "post": { + "description": "These come from the GitHub app.", + "operationId": "apps_github_webhook", + "requestBody": { + "content": { + "application/octet-stream": { + "schema": { + "format": "binary", + "type": "string" + } + } + }, + "required": true + }, + "responses": { + "204": { + "description": "successful operation, no content", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Listen for GitHub webhooks.", + "tags": [ + "apps", + "hidden" + ] + } + }, "/async/operations": { "get": { "description": "For async file conversion operations, this endpoint does not return the contents of converted files (`output`). To get the contents use the `/async/operations/{id}` endpoint.\nThis endpoint requires authentication by a KittyCAD employee.", @@ -5838,10 +8509,1546 @@ ] } }, - "/unit/conversion/{src_format}/{output_format}": { - "post": { - "description": "Convert a metric unit value to another metric unit value. This is a nice endpoint to use for helper functions.", - "operationId": "create_unit_conversion", + "/unit/conversion/acceleration/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_acceleration_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitAccelerationFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitAccelerationFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitAccelerationConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/angle/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_angle_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitAngleFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitAngleFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitAngleConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/angular-velocity/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_angular_velocity_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitAngularVelocityFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitAngularVelocityFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitAngularVelocityConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/area/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_area_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitAreaFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitAreaFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitAreaConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/charge/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_charge_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitChargeFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitChargeFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitChargeConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/concentration/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_concentration_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitConcentrationFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitConcentrationFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitConcentrationConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/data-transfer-rate/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_data_transfer_rate_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitDataTransferRateFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitDataTransferRateFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitDataTransferRateConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/data/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_data_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitDataFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitDataFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitDataConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/density/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_density_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitDensityFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitDensityFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitDensityConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/energy/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_energy_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitEnergyFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitEnergyFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitEnergyConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/force/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_force_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitForceFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitForceFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitForceConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/illuminance/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_illuminance_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitIlluminanceFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitIlluminanceFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitIlluminanceConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/length/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_length_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitLengthFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitLengthFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitLengthConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/magnetic-field-strength/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_magnetic_field_strength_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitMagneticFieldStrengthFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitMagneticFieldStrengthFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitMagneticFieldStrengthConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/magnetic-flux/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_magnetic_flux_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitMagneticFluxFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitMagneticFluxFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitMagneticFluxConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/mass/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_mass_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitMassFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitMassFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitMassConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/metric/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_metric_unit_conversion", "parameters": [ { "description": "The output format of the unit.", @@ -5876,15 +10083,879 @@ } ], "responses": { - "201": { + "200": { "content": { "application/json": { "schema": { - "$ref": "#/components/schemas/UnitConversion" + "$ref": "#/components/schemas/UnitMetricConversion" } } }, - "description": "successful creation", + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/power/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_power_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitPowerFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitPowerFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitPowerConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/pressure/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_pressure_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitPressureFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitPressureFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitPressureConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/radiation/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_radiation_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitRadiationFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitRadiationFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitRadiationConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/solid-angle/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_solid_angle_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitSolidAngleFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitSolidAngleFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitSolidAngleConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/temperature/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_temperature_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitTemperatureFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitTemperatureFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitTemperatureConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/time/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_time_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitTimeFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitTimeFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitTimeConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/velocity/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_velocity_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitVelocityFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitVelocityFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitVelocityConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/voltage/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_voltage_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitVoltageFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitVoltageFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitVoltageConversion" + } + } + }, + "description": "successful operation", + "headers": { + "Access-Control-Allow-Credentials": { + "description": "Access-Control-Allow-Credentials header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Headers": { + "description": "Access-Control-Allow-Headers header. This is a comma-separated list of headers.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Methods": { + "description": "Access-Control-Allow-Methods header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + }, + "Access-Control-Allow-Origin": { + "description": "Access-Control-Allow-Origin header.", + "required": true, + "schema": { + "type": "string" + }, + "style": "simple" + } + } + }, + "4XX": { + "$ref": "#/components/responses/Error" + }, + "5XX": { + "$ref": "#/components/responses/Error" + } + }, + "summary": "Convert units.", + "tags": [ + "unit", + "beta" + ] + } + }, + "/unit/conversion/volume/{src_format}/{output_format}": { + "get": { + "description": "Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions.", + "operationId": "get_volume_unit_conversion", + "parameters": [ + { + "description": "The output format of the unit.", + "in": "path", + "name": "output_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitVolumeFormat" + }, + "style": "simple" + }, + { + "description": "The source format of the unit.", + "in": "path", + "name": "src_format", + "required": true, + "schema": { + "$ref": "#/components/schemas/UnitVolumeFormat" + }, + "style": "simple" + }, + { + "description": "The initial value.", + "in": "query", + "name": "value", + "required": true, + "schema": { + "format": "float", + "type": "number" + }, + "style": "form" + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UnitVolumeConversion" + } + } + }, + "description": "successful operation", "headers": { "Access-Control-Allow-Credentials": { "description": "Access-Control-Allow-Credentials header.", From 0d39b80547afeba043ab9163678be31752e9f85d Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 25 Jul 2022 22:46:48 +0000 Subject: [PATCH 2/2] I have generated the latest API! --- kittycad.py.patch.json | 2 +- kittycad/api/apps/apps_github_webhook.py | 109 +++++++++++ .../unit/get_acceleration_unit_conversion.py | 129 ++++++++++++ .../api/unit/get_angle_unit_conversion.py | 129 ++++++++++++ .../get_angular_velocity_unit_conversion.py | 129 ++++++++++++ kittycad/api/unit/get_area_unit_conversion.py | 129 ++++++++++++ .../api/unit/get_charge_unit_conversion.py | 129 ++++++++++++ .../unit/get_concentration_unit_conversion.py | 129 ++++++++++++ .../get_data_transfer_rate_unit_conversion.py | 129 ++++++++++++ kittycad/api/unit/get_data_unit_conversion.py | 129 ++++++++++++ .../api/unit/get_density_unit_conversion.py | 129 ++++++++++++ .../api/unit/get_energy_unit_conversion.py | 129 ++++++++++++ .../api/unit/get_force_unit_conversion.py | 129 ++++++++++++ .../unit/get_illuminance_unit_conversion.py | 129 ++++++++++++ .../api/unit/get_length_unit_conversion.py | 129 ++++++++++++ ...magnetic_field_strength_unit_conversion.py | 129 ++++++++++++ .../unit/get_magnetic_flux_unit_conversion.py | 129 ++++++++++++ kittycad/api/unit/get_mass_unit_conversion.py | 129 ++++++++++++ ...rsion.py => get_metric_unit_conversion.py} | 30 +-- .../api/unit/get_power_unit_conversion.py | 129 ++++++++++++ .../api/unit/get_pressure_unit_conversion.py | 129 ++++++++++++ .../api/unit/get_radiation_unit_conversion.py | 129 ++++++++++++ .../unit/get_solid_angle_unit_conversion.py | 129 ++++++++++++ .../unit/get_temperature_unit_conversion.py | 129 ++++++++++++ kittycad/api/unit/get_time_unit_conversion.py | 129 ++++++++++++ .../api/unit/get_velocity_unit_conversion.py | 129 ++++++++++++ .../api/unit/get_voltage_unit_conversion.py | 129 ++++++++++++ .../api/unit/get_volume_unit_conversion.py | 129 ++++++++++++ kittycad/models/__init__.py | 52 ++++- .../models/unit_acceleration_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_acceleration_format.py | 10 + kittycad/models/unit_angle_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_angle_format.py | 14 ++ .../unit_angular_velocity_conversion.py | 185 ++++++++++++++++++ .../models/unit_angular_velocity_format.py | 11 ++ kittycad/models/unit_area_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_area_format.py | 14 ++ kittycad/models/unit_charge_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_charge_format.py | 9 + .../models/unit_concentration_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_concentration_format.py | 11 ++ kittycad/models/unit_data_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_data_format.py | 11 ++ .../unit_data_transfer_rate_conversion.py | 185 ++++++++++++++++++ .../models/unit_data_transfer_rate_format.py | 11 ++ kittycad/models/unit_density_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_density_format.py | 17 ++ kittycad/models/unit_energy_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_energy_format.py | 13 ++ kittycad/models/unit_force_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_force_format.py | 12 ++ .../models/unit_illuminance_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_illuminance_format.py | 11 ++ kittycad/models/unit_length_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_length_format.py | 21 ++ ...unit_magnetic_field_strength_conversion.py | 185 ++++++++++++++++++ .../unit_magnetic_field_strength_format.py | 9 + .../models/unit_magnetic_flux_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_magnetic_flux_format.py | 9 + kittycad/models/unit_mass_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_mass_format.py | 16 ++ ...onversion.py => unit_metric_conversion.py} | 10 +- kittycad/models/unit_power_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_power_format.py | 10 + kittycad/models/unit_pressure_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_pressure_format.py | 12 ++ kittycad/models/unit_radiation_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_radiation_format.py | 10 + .../models/unit_solid_angle_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_solid_angle_format.py | 10 + .../models/unit_temperature_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_temperature_format.py | 12 ++ kittycad/models/unit_time_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_time_format.py | 15 ++ kittycad/models/unit_velocity_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_velocity_format.py | 12 ++ kittycad/models/unit_voltage_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_voltage_format.py | 10 + kittycad/models/unit_volume_conversion.py | 185 ++++++++++++++++++ kittycad/models/unit_volume_format.py | 14 ++ 80 files changed, 8335 insertions(+), 22 deletions(-) create mode 100644 kittycad/api/apps/apps_github_webhook.py create mode 100644 kittycad/api/unit/get_acceleration_unit_conversion.py create mode 100644 kittycad/api/unit/get_angle_unit_conversion.py create mode 100644 kittycad/api/unit/get_angular_velocity_unit_conversion.py create mode 100644 kittycad/api/unit/get_area_unit_conversion.py create mode 100644 kittycad/api/unit/get_charge_unit_conversion.py create mode 100644 kittycad/api/unit/get_concentration_unit_conversion.py create mode 100644 kittycad/api/unit/get_data_transfer_rate_unit_conversion.py create mode 100644 kittycad/api/unit/get_data_unit_conversion.py create mode 100644 kittycad/api/unit/get_density_unit_conversion.py create mode 100644 kittycad/api/unit/get_energy_unit_conversion.py create mode 100644 kittycad/api/unit/get_force_unit_conversion.py create mode 100644 kittycad/api/unit/get_illuminance_unit_conversion.py create mode 100644 kittycad/api/unit/get_length_unit_conversion.py create mode 100644 kittycad/api/unit/get_magnetic_field_strength_unit_conversion.py create mode 100644 kittycad/api/unit/get_magnetic_flux_unit_conversion.py create mode 100644 kittycad/api/unit/get_mass_unit_conversion.py rename kittycad/api/unit/{create_unit_conversion.py => get_metric_unit_conversion.py} (70%) create mode 100644 kittycad/api/unit/get_power_unit_conversion.py create mode 100644 kittycad/api/unit/get_pressure_unit_conversion.py create mode 100644 kittycad/api/unit/get_radiation_unit_conversion.py create mode 100644 kittycad/api/unit/get_solid_angle_unit_conversion.py create mode 100644 kittycad/api/unit/get_temperature_unit_conversion.py create mode 100644 kittycad/api/unit/get_time_unit_conversion.py create mode 100644 kittycad/api/unit/get_velocity_unit_conversion.py create mode 100644 kittycad/api/unit/get_voltage_unit_conversion.py create mode 100644 kittycad/api/unit/get_volume_unit_conversion.py create mode 100644 kittycad/models/unit_acceleration_conversion.py create mode 100644 kittycad/models/unit_acceleration_format.py create mode 100644 kittycad/models/unit_angle_conversion.py create mode 100644 kittycad/models/unit_angle_format.py create mode 100644 kittycad/models/unit_angular_velocity_conversion.py create mode 100644 kittycad/models/unit_angular_velocity_format.py create mode 100644 kittycad/models/unit_area_conversion.py create mode 100644 kittycad/models/unit_area_format.py create mode 100644 kittycad/models/unit_charge_conversion.py create mode 100644 kittycad/models/unit_charge_format.py create mode 100644 kittycad/models/unit_concentration_conversion.py create mode 100644 kittycad/models/unit_concentration_format.py create mode 100644 kittycad/models/unit_data_conversion.py create mode 100644 kittycad/models/unit_data_format.py create mode 100644 kittycad/models/unit_data_transfer_rate_conversion.py create mode 100644 kittycad/models/unit_data_transfer_rate_format.py create mode 100644 kittycad/models/unit_density_conversion.py create mode 100644 kittycad/models/unit_density_format.py create mode 100644 kittycad/models/unit_energy_conversion.py create mode 100644 kittycad/models/unit_energy_format.py create mode 100644 kittycad/models/unit_force_conversion.py create mode 100644 kittycad/models/unit_force_format.py create mode 100644 kittycad/models/unit_illuminance_conversion.py create mode 100644 kittycad/models/unit_illuminance_format.py create mode 100644 kittycad/models/unit_length_conversion.py create mode 100644 kittycad/models/unit_length_format.py create mode 100644 kittycad/models/unit_magnetic_field_strength_conversion.py create mode 100644 kittycad/models/unit_magnetic_field_strength_format.py create mode 100644 kittycad/models/unit_magnetic_flux_conversion.py create mode 100644 kittycad/models/unit_magnetic_flux_format.py create mode 100644 kittycad/models/unit_mass_conversion.py create mode 100644 kittycad/models/unit_mass_format.py rename kittycad/models/{unit_conversion.py => unit_metric_conversion.py} (96%) create mode 100644 kittycad/models/unit_power_conversion.py create mode 100644 kittycad/models/unit_power_format.py create mode 100644 kittycad/models/unit_pressure_conversion.py create mode 100644 kittycad/models/unit_pressure_format.py create mode 100644 kittycad/models/unit_radiation_conversion.py create mode 100644 kittycad/models/unit_radiation_format.py create mode 100644 kittycad/models/unit_solid_angle_conversion.py create mode 100644 kittycad/models/unit_solid_angle_format.py create mode 100644 kittycad/models/unit_temperature_conversion.py create mode 100644 kittycad/models/unit_temperature_format.py create mode 100644 kittycad/models/unit_time_conversion.py create mode 100644 kittycad/models/unit_time_format.py create mode 100644 kittycad/models/unit_velocity_conversion.py create mode 100644 kittycad/models/unit_velocity_format.py create mode 100644 kittycad/models/unit_voltage_conversion.py create mode 100644 kittycad/models/unit_voltage_format.py create mode 100644 kittycad/models/unit_volume_conversion.py create mode 100644 kittycad/models/unit_volume_format.py diff --git a/kittycad.py.patch.json b/kittycad.py.patch.json index df8a3f38b..4a2fe0977 100644 --- a/kittycad.py.patch.json +++ b/kittycad.py.patch.json @@ -1 +1 @@ -[{"op": "add", "path": "/components/responses/Error/content/application~1json/schema/x-scope", "value": ["", "#/components/responses/Error"]}, {"op": "add", "path": "/components/schemas/ApiToken/properties/token/allOf/0/x-scope", "value": ["", "#/components/schemas/ApiTokenResultsPage", "#/components/schemas/ApiToken"]}, {"op": "add", "path": "/components/schemas/BillingInfo/properties/address/allOf/0/x-scope", "value": ["", "#/components/schemas/BillingInfo"]}, {"op": "add", "path": "/components/schemas/Metadata/properties/cache/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata"]}, {"op": "add", "path": "/components/schemas/Metadata/properties/environment/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata"]}, {"op": "add", "path": "/components/schemas/Metadata/properties/pubsub/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata"]}, {"op": "add", "path": "/components/schemas/Metadata/properties/fs/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata"]}, {"op": "add", "path": "/components/schemas/Metadata/properties/executor/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata"]}, {"op": "add", "path": "/components/schemas/Metadata/properties/engine/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata"]}, {"op": "add", "path": "/components/schemas/Address/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/Customer", "#/components/schemas/Address"]}, {"op": "add", "path": "/components/schemas/Invoice/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/Invoice"]}, {"op": "add", "path": "/components/schemas/Invoice/properties/currency/allOf/0/x-scope", "value": ["", "#/components/schemas/Invoice"]}, {"op": "add", "path": "/components/schemas/Invoice/properties/lines/items/x-scope", "value": ["", "#/components/schemas/Invoice"]}, {"op": "add", "path": "/components/schemas/InvoiceLineItem/properties/currency/allOf/0/x-scope", "value": ["", "#/components/schemas/Invoice", "#/components/schemas/InvoiceLineItem"]}, {"op": "add", "path": "/components/schemas/ApiCallWithPrice/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/ApiCallWithPriceResultsPage", "#/components/schemas/ApiCallWithPrice"]}, {"op": "add", "path": "/components/schemas/ApiCallWithPrice/properties/token/allOf/0/x-scope", "value": ["", "#/components/schemas/ApiCallWithPriceResultsPage", "#/components/schemas/ApiCallWithPrice"]}, {"op": "add", "path": "/components/schemas/ApiCallWithPrice/properties/method/allOf/0/x-scope", "value": ["", "#/components/schemas/ApiCallWithPriceResultsPage", "#/components/schemas/ApiCallWithPrice"]}, {"op": "add", "path": "/components/schemas/ExtendedUserResultsPage/properties/items/items/x-scope", "value": ["", "#/components/schemas/ExtendedUserResultsPage"]}, {"op": "add", "path": "/components/schemas/Customer/properties/currency/allOf/0/x-scope", "value": ["", "#/components/schemas/Customer"]}, {"op": "add", "path": "/components/schemas/Customer/properties/address/allOf/0/x-scope", "value": ["", "#/components/schemas/Customer"]}, {"op": "add", "path": "/components/schemas/RegistryServiceConfig/properties/index_configs/additionalProperties/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo", "#/components/schemas/RegistryServiceConfig"]}, {"op": "add", "path": "/components/schemas/ApiCallWithPriceResultsPage/properties/items/items/x-scope", "value": ["", "#/components/schemas/ApiCallWithPriceResultsPage"]}, {"op": "add", "path": "/components/schemas/FileVolume/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/FileVolume"]}, {"op": "add", "path": "/components/schemas/FileVolume/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/FileVolume"]}, {"op": "add", "path": "/components/schemas/FileVolume/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/FileVolume"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/registry_config/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/cgroup_version/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/init_commit/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/default_address_pools/items/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/isolation/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/runtimes/additionalProperties/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/cgroup_driver/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/runc_commit/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/containerd_commit/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/plugins/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/FileDensity/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/FileDensity"]}, {"op": "add", "path": "/components/schemas/FileDensity/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/FileDensity"]}, {"op": "add", "path": "/components/schemas/FileDensity/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/FileDensity"]}, {"op": "add", "path": "/components/schemas/ExecutorMetadata/properties/environment/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata"]}, {"op": "add", "path": "/components/schemas/ExecutorMetadata/properties/docker_info/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata"]}, {"op": "add", "path": "/components/schemas/FileMass/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/FileMass"]}, {"op": "add", "path": "/components/schemas/FileMass/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/FileMass"]}, {"op": "add", "path": "/components/schemas/FileMass/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/FileMass"]}, {"op": "add", "path": "/components/schemas/DeviceAccessTokenRequestForm/properties/grant_type/allOf/0/x-scope", "value": ["", "#/components/schemas/DeviceAccessTokenRequestForm"]}, {"op": "add", "path": "/components/schemas/Jetstream/properties/meta/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/Connection", "#/components/schemas/Jetstream"]}, {"op": "add", "path": "/components/schemas/Jetstream/properties/config/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/Connection", "#/components/schemas/Jetstream"]}, {"op": "add", "path": "/components/schemas/Jetstream/properties/stats/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/Connection", "#/components/schemas/Jetstream"]}, {"op": "add", "path": "/components/schemas/PaymentMethod/properties/card/allOf/0/x-scope", "value": ["", "#/components/schemas/PaymentMethod"]}, {"op": "add", "path": "/components/schemas/PaymentMethod/properties/type/allOf/0/x-scope", "value": ["", "#/components/schemas/PaymentMethod"]}, {"op": "add", "path": "/components/schemas/PaymentMethod/properties/billing_info/allOf/0/x-scope", "value": ["", "#/components/schemas/PaymentMethod"]}, {"op": "add", "path": "/components/schemas/UserResultsPage/properties/items/items/x-scope", "value": ["", "#/components/schemas/UserResultsPage"]}, {"op": "add", "path": "/components/schemas/Connection/properties/leaf/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/Connection"]}, {"op": "add", "path": "/components/schemas/Connection/properties/gateway/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/Connection"]}, {"op": "add", "path": "/components/schemas/Connection/properties/jetstream/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/Connection"]}, {"op": "add", "path": "/components/schemas/Connection/properties/cluster/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/Connection"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallResultsPage/properties/items/items/x-scope", "value": ["", "#/components/schemas/AsyncApiCallResultsPage"]}, {"op": "add", "path": "/components/schemas/AsyncApiCall/properties/type/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallResultsPage", "#/components/schemas/AsyncApiCall"]}, {"op": "add", "path": "/components/schemas/AsyncApiCall/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallResultsPage", "#/components/schemas/AsyncApiCall"]}, {"op": "add", "path": "/components/schemas/AsyncApiCall/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallResultsPage", "#/components/schemas/AsyncApiCall"]}, {"op": "add", "path": "/components/schemas/CodeOutput/properties/output_files/items/x-scope", "value": ["", "#/components/schemas/CodeOutput"]}, {"op": "add", "path": "/components/schemas/UnitConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitConversion"]}, {"op": "add", "path": "/components/schemas/UnitConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitConversion"]}, {"op": "add", "path": "/components/schemas/UnitConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitConversion"]}, {"op": "add", "path": "/components/schemas/UnitConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitConversion"]}, {"op": "add", "path": "/components/schemas/JetstreamStats/properties/api/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/Connection", "#/components/schemas/Jetstream", "#/components/schemas/JetstreamStats"]}, {"op": "add", "path": "/components/schemas/FileConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/FileConversion"]}, {"op": "add", "path": "/components/schemas/FileConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/FileConversion"]}, {"op": "add", "path": "/components/schemas/FileConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/FileConversion"]}, {"op": "add", "path": "/components/schemas/FileConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/FileConversion"]}, {"op": "add", "path": "/components/schemas/CustomerBalance/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/CustomerBalance"]}, {"op": "add", "path": "/components/schemas/Session/properties/session_token/allOf/0/x-scope", "value": ["", "#/components/schemas/Session"]}, {"op": "add", "path": "/components/schemas/ApiTokenResultsPage/properties/items/items/x-scope", "value": ["", "#/components/schemas/ApiTokenResultsPage"]}, {"op": "add", "path": "/components/schemas/EngineMetadata/properties/cache/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata"]}, {"op": "add", "path": "/components/schemas/EngineMetadata/properties/environment/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata"]}, {"op": "add", "path": "/components/schemas/EngineMetadata/properties/pubsub/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata"]}, {"op": "add", "path": "/components/schemas/EngineMetadata/properties/fs/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/0/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/0/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/0/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/0/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/1/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/1/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/1/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/2/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/2/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/2/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/3/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/3/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/3/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/CardDetails/properties/checks/allOf/0/x-scope", "value": ["", "#/components/schemas/PaymentMethod", "#/components/schemas/CardDetails"]}, {"op": "add", "path": "/info/x-python", "value": {"client": "# Create a client with your token.\nfrom kittycad import Client\n\nclient = Client(token=\"$TOKEN\")\n\n# - OR -\n\n# Create a new client with your token parsed from the environment variable:\n# `KITTYCAD_API_TOKEN`.\nfrom kittycad import ClientFromEnv\n\nclient = ClientFromEnv()", "install": "pip install kittycad"}}, {"op": "add", "path": "/paths/~1user~1payment~1methods~1{id}/delete/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.payments import delete_payment_method_for_user\nfrom kittycad.types import Response\n\nfc: Error = delete_payment_method_for_user.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = delete_payment_method_for_user.sync_detailed(client=client, id=)\n\n# OR run async\nfc: Error = await delete_payment_method_for_user.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[Error] = await delete_payment_method_for_user.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.delete_payment_method_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment~1methods~1{id}/delete/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1methods~1{id}/delete/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1methods~1{id}/options/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1methods~1{id}/options/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1{src_format}~1{output_format}/post/x-python", "value": {"example": "from kittycad.models import UnitConversion\nfrom kittycad.api.unit import create_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitConversion = create_unit_conversion.sync(client=client, output_format=UnitMetricFormat, src_format=UnitMetricFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitConversion] = create_unit_conversion.sync_detailed(client=client, output_format=UnitMetricFormat, src_format=UnitMetricFormat, value=\"\")\n\n# OR run async\nfc: UnitConversion = await create_unit_conversion.asyncio(client=client, output_format=UnitMetricFormat, src_format=UnitMetricFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitConversion] = await create_unit_conversion.asyncio_detailed(client=client, output_format=UnitMetricFormat, src_format=UnitMetricFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.create_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1{src_format}~1{output_format}/post/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1{src_format}~1{output_format}/post/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1{src_format}~1{output_format}/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1{src_format}~1{output_format}/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1{src_format}~1{output_format}/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users/get/x-python", "value": {"example": "from kittycad.models import UserResultsPage\nfrom kittycad.api.users import list_users\nfrom kittycad.types import Response\n\nfc: UserResultsPage = list_users.sync(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UserResultsPage] = list_users.sync_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async\nfc: UserResultsPage = await list_users.asyncio(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async with more info\nresponse: Response[UserResultsPage] = await list_users.asyncio_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.list_users.html"}}, {"op": "add", "path": "/paths/~1users/get/parameters/2/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1density/post/x-python", "value": {"example": "from kittycad.models import FileDensity\nfrom kittycad.api.file import create_file_density\nfrom kittycad.types import Response\n\nfc: FileDensity = create_file_density.sync(client=client, material_mass=\"\", src_format=FileSourceFormat, body=bytes)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileDensity] = create_file_density.sync_detailed(client=client, material_mass=\"\", src_format=FileSourceFormat, body=bytes)\n\n# OR run async\nfc: FileDensity = await create_file_density.asyncio(client=client, material_mass=\"\", src_format=FileSourceFormat, body=bytes)\n\n# OR run async with more info\nresponse: Response[FileDensity] = await create_file_density.asyncio_detailed(client=client, material_mass=\"\", src_format=FileSourceFormat, body=bytes)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.create_file_density.html"}}, {"op": "add", "path": "/paths/~1file~1density/post/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1density/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1density/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1density/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls~1{id}/get/x-python", "value": {"example": "from kittycad.models import ApiCallWithPrice\nfrom kittycad.api.api-calls import get_api_call_for_user\nfrom kittycad.types import Response\n\nfc: ApiCallWithPrice = get_api_call_for_user.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiCallWithPrice] = get_api_call_for_user.sync_detailed(client=client, id=)\n\n# OR run async\nfc: ApiCallWithPrice = await get_api_call_for_user.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[ApiCallWithPrice] = await get_api_call_for_user.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.get_api_call_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1api-calls~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls~1{id}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended/get/x-python", "value": {"example": "from kittycad.models import ExtendedUserResultsPage\nfrom kittycad.api.users import list_users_extended\nfrom kittycad.types import Response\n\nfc: ExtendedUserResultsPage = list_users_extended.sync(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ExtendedUserResultsPage] = list_users_extended.sync_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async\nfc: ExtendedUserResultsPage = await list_users_extended.asyncio(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async with more info\nresponse: Response[ExtendedUserResultsPage] = await list_users_extended.asyncio_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.list_users_extended.html"}}, {"op": "add", "path": "/paths/~1users-extended/get/parameters/2/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email/options/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email/options/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email/post/x-python", "value": {"example": "from kittycad.models import VerificationToken\nfrom kittycad.api.hidden import auth_email\nfrom kittycad.types import Response\n\nfc: VerificationToken = auth_email.sync(client=client, body=EmailAuthenticationForm)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[VerificationToken] = auth_email.sync_detailed(client=client, body=EmailAuthenticationForm)\n\n# OR run async\nfc: VerificationToken = await auth_email.asyncio(client=client, body=EmailAuthenticationForm)\n\n# OR run async with more info\nresponse: Response[VerificationToken] = await auth_email.asyncio_detailed(client=client, body=EmailAuthenticationForm)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.hidden.auth_email.html"}}, {"op": "add", "path": "/paths/~1auth~1email/post/requestBody/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1confirm/options/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1confirm/options/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1confirm/post/requestBody/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1confirm/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1confirm/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1extended/get/x-python", "value": {"example": "from kittycad.models import ExtendedUser\nfrom kittycad.api.users import get_user_self_extended\nfrom kittycad.types import Response\n\nfc: ExtendedUser = get_user_self_extended.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ExtendedUser] = get_user_self_extended.sync_detailed(client=client)\n\n# OR run async\nfc: ExtendedUser = await get_user_self_extended.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[ExtendedUser] = await get_user_self_extended.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.get_user_self_extended.html"}}, {"op": "add", "path": "/paths/~1user~1extended/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1extended/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1extended/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1apps~1github~1callback/get/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.apps import apps_github_callback\nfrom kittycad.types import Response\n\nfc: Error = apps_github_callback.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = apps_github_callback.sync_detailed(client=client)\n\n# OR run async\nfc: Error = await apps_github_callback.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Error] = await apps_github_callback.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.apps.apps_github_callback.html"}}, {"op": "add", "path": "/paths/~1apps~1github~1callback/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1apps~1github~1callback/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations/get/x-python", "value": {"example": "from kittycad.models import AsyncApiCallResultsPage\nfrom kittycad.api.api-calls import list_async_operations\nfrom kittycad.types import Response\n\nfc: AsyncApiCallResultsPage = list_async_operations.sync(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode, status=ApiCallStatus)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[AsyncApiCallResultsPage] = list_async_operations.sync_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode, status=ApiCallStatus)\n\n# OR run async\nfc: AsyncApiCallResultsPage = await list_async_operations.asyncio(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode, status=ApiCallStatus)\n\n# OR run async with more info\nresponse: Response[AsyncApiCallResultsPage] = await list_async_operations.asyncio_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode, status=ApiCallStatus)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.list_async_operations.html"}}, {"op": "add", "path": "/paths/~1async~1operations/get/parameters/2/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations/get/parameters/3/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1balance/get/x-python", "value": {"example": "from kittycad.models import CustomerBalance\nfrom kittycad.api.payments import get_payment_balance_for_user\nfrom kittycad.types import Response\n\nfc: CustomerBalance = get_payment_balance_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[CustomerBalance] = get_payment_balance_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: CustomerBalance = await get_payment_balance_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[CustomerBalance] = await get_payment_balance_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.get_payment_balance_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment~1balance/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1balance/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1balance/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1logout/post/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.hidden import logout\nfrom kittycad.types import Response\n\nfc: Error = logout.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = logout.sync_detailed(client=client)\n\n# OR run async\nfc: Error = await logout.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Error] = await logout.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.hidden.logout.html"}}, {"op": "add", "path": "/paths/~1logout/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1logout/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1session~1{token}/get/x-python", "value": {"example": "from kittycad.models import Session\nfrom kittycad.api.sessions import get_session_for_user\nfrom kittycad.types import Response\n\nfc: Session = get_session_for_user.sync(client=client, token=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Session] = get_session_for_user.sync_detailed(client=client, token=\"\")\n\n# OR run async\nfc: Session = await get_session_for_user.asyncio(client=client, token=\"\")\n\n# OR run async with more info\nresponse: Response[Session] = await get_session_for_user.asyncio_detailed(client=client, token=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.sessions.get_session_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1session~1{token}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1session~1{token}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1session~1{token}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1callback/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1callback/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1callback/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended~1{id}/get/x-python", "value": {"example": "from kittycad.models import ExtendedUser\nfrom kittycad.api.users import get_user_extended\nfrom kittycad.types import Response\n\nfc: ExtendedUser = get_user_extended.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ExtendedUser] = get_user_extended.sync_detailed(client=client, id=)\n\n# OR run async\nfc: ExtendedUser = await get_user_extended.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[ExtendedUser] = await get_user_extended.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.get_user_extended.html"}}, {"op": "add", "path": "/paths/~1users-extended~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended~1{id}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}/get/x-python", "value": {"example": "from kittycad.models import User\nfrom kittycad.api.users import get_user\nfrom kittycad.types import Response\n\nfc: User = get_user.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[User] = get_user.sync_detailed(client=client, id=)\n\n# OR run async\nfc: User = await get_user.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[User] = await get_user.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.get_user.html"}}, {"op": "add", "path": "/paths/~1users~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1methods/get/x-python", "value": {"example": "from kittycad.models import [PaymentMethod]\nfrom kittycad.api.payments import list_payment_methods_for_user\nfrom kittycad.types import Response\n\nfc: [PaymentMethod] = list_payment_methods_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[[PaymentMethod]] = list_payment_methods_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: [PaymentMethod] = await list_payment_methods_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[[PaymentMethod]] = await list_payment_methods_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.list_payment_methods_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment~1methods/get/responses/200/content/application~1json/schema/items/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1methods/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1methods/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/delete/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.api-tokens import delete_api_token_for_user\nfrom kittycad.types import Response\n\nfc: Error = delete_api_token_for_user.sync(client=client, token=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = delete_api_token_for_user.sync_detailed(client=client, token=\"\")\n\n# OR run async\nfc: Error = await delete_api_token_for_user.asyncio(client=client, token=\"\")\n\n# OR run async with more info\nresponse: Response[Error] = await delete_api_token_for_user.asyncio_detailed(client=client, token=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-tokens.delete_api_token_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/delete/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/delete/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/options/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/options/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/get/x-python", "value": {"example": "from kittycad.models import ApiToken\nfrom kittycad.api.api-tokens import get_api_token_for_user\nfrom kittycad.types import Response\n\nfc: ApiToken = get_api_token_for_user.sync(client=client, token=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiToken] = get_api_token_for_user.sync_detailed(client=client, token=\"\")\n\n# OR run async\nfc: ApiToken = await get_api_token_for_user.asyncio(client=client, token=\"\")\n\n# OR run async with more info\nresponse: Response[ApiToken] = await get_api_token_for_user.asyncio_detailed(client=client, token=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-tokens.get_api_token_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1/get/x-python", "value": {"example": "from kittycad.models import dict\nfrom kittycad.api.meta import get_schema\nfrom kittycad.types import Response\n\nfc: dict = get_schema.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[dict] = get_schema.sync_detailed(client=client)\n\n# OR run async\nfc: dict = await get_schema.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[dict] = await get_schema.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.meta.get_schema.html"}}, {"op": "add", "path": "/paths/~1/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/delete/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.payments import delete_payment_information_for_user\nfrom kittycad.types import Response\n\nfc: Error = delete_payment_information_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = delete_payment_information_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: Error = await delete_payment_information_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Error] = await delete_payment_information_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.delete_payment_information_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment/delete/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/delete/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/post/x-python", "value": {"example": "from kittycad.models import Customer\nfrom kittycad.api.payments import create_payment_information_for_user\nfrom kittycad.types import Response\n\nfc: Customer = create_payment_information_for_user.sync(client=client, body=BillingInfo)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Customer] = create_payment_information_for_user.sync_detailed(client=client, body=BillingInfo)\n\n# OR run async\nfc: Customer = await create_payment_information_for_user.asyncio(client=client, body=BillingInfo)\n\n# OR run async with more info\nresponse: Response[Customer] = await create_payment_information_for_user.asyncio_detailed(client=client, body=BillingInfo)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.create_payment_information_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment/post/requestBody/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/put/x-python", "value": {"example": "from kittycad.models import Customer\nfrom kittycad.api.payments import update_payment_information_for_user\nfrom kittycad.types import Response\n\nfc: Customer = update_payment_information_for_user.sync(client=client, body=BillingInfo)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Customer] = update_payment_information_for_user.sync_detailed(client=client, body=BillingInfo)\n\n# OR run async\nfc: Customer = await update_payment_information_for_user.asyncio(client=client, body=BillingInfo)\n\n# OR run async with more info\nresponse: Response[Customer] = await update_payment_information_for_user.asyncio_detailed(client=client, body=BillingInfo)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.update_payment_information_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment/put/requestBody/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/put/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/put/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/put/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/get/x-python", "value": {"example": "from kittycad.models import Customer\nfrom kittycad.api.payments import get_payment_information_for_user\nfrom kittycad.types import Response\n\nfc: Customer = get_payment_information_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Customer] = get_payment_information_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: Customer = await get_payment_information_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Customer] = await get_payment_information_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.get_payment_information_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/options/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/options/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1ping/get/x-python", "value": {"example": "from kittycad.models import Pong\nfrom kittycad.api.meta import ping\nfrom kittycad.types import Response\n\nfc: Pong = ping.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Pong] = ping.sync_detailed(client=client)\n\n# OR run async\nfc: Pong = await ping.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Pong] = await ping.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.meta.ping.html"}}, {"op": "add", "path": "/paths/~1ping/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1ping/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1ping/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email~1callback/get/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.hidden import auth_email_callback\nfrom kittycad.types import Response\n\nfc: Error = auth_email_callback.sync(client=client, callback_url=\"\", email=\"\", token=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = auth_email_callback.sync_detailed(client=client, callback_url=\"\", email=\"\", token=)\n\n# OR run async\nfc: Error = await auth_email_callback.asyncio(client=client, callback_url=\"\", email=\"\", token=)\n\n# OR run async with more info\nresponse: Response[Error] = await auth_email_callback.asyncio_detailed(client=client, callback_url=\"\", email=\"\", token=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.hidden.auth_email_callback.html"}}, {"op": "add", "path": "/paths/~1auth~1email~1callback/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email~1callback/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1apps~1github~1consent/get/x-python", "value": {"example": "from kittycad.models import AppClientInfo\nfrom kittycad.api.apps import apps_github_consent\nfrom kittycad.types import Response\n\nfc: AppClientInfo = apps_github_consent.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[AppClientInfo] = apps_github_consent.sync_detailed(client=client)\n\n# OR run async\nfc: AppClientInfo = await apps_github_consent.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[AppClientInfo] = await apps_github_consent.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.apps.apps_github_consent.html"}}, {"op": "add", "path": "/paths/~1apps~1github~1consent/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1apps~1github~1consent/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1apps~1github~1consent/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-call-metrics/get/x-python", "value": {"example": "from kittycad.models import [ApiCallQueryGroup]\nfrom kittycad.api.api-calls import get_api_call_metrics\nfrom kittycad.types import Response\n\nfc: [ApiCallQueryGroup] = get_api_call_metrics.sync(client=client, group_by=ApiCallQueryGroupBy)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[[ApiCallQueryGroup]] = get_api_call_metrics.sync_detailed(client=client, group_by=ApiCallQueryGroupBy)\n\n# OR run async\nfc: [ApiCallQueryGroup] = await get_api_call_metrics.asyncio(client=client, group_by=ApiCallQueryGroupBy)\n\n# OR run async with more info\nresponse: Response[[ApiCallQueryGroup]] = await get_api_call_metrics.asyncio_detailed(client=client, group_by=ApiCallQueryGroupBy)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.get_api_call_metrics.html"}}, {"op": "add", "path": "/paths/~1api-call-metrics/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-call-metrics/get/responses/200/content/application~1json/schema/items/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-call-metrics/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-call-metrics/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1consent/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1consent/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1consent/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1consent/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1invoices/get/x-python", "value": {"example": "from kittycad.models import [Invoice]\nfrom kittycad.api.payments import list_invoices_for_user\nfrom kittycad.types import Response\n\nfc: [Invoice] = list_invoices_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[[Invoice]] = list_invoices_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: [Invoice] = await list_invoices_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[[Invoice]] = await list_invoices_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.list_invoices_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment~1invoices/get/responses/200/content/application~1json/schema/items/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1invoices/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1invoices/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1volume/post/x-python", "value": {"example": "from kittycad.models import FileVolume\nfrom kittycad.api.file import create_file_volume\nfrom kittycad.types import Response\n\nfc: FileVolume = create_file_volume.sync(client=client, src_format=FileSourceFormat, body=bytes)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileVolume] = create_file_volume.sync_detailed(client=client, src_format=FileSourceFormat, body=bytes)\n\n# OR run async\nfc: FileVolume = await create_file_volume.asyncio(client=client, src_format=FileSourceFormat, body=bytes)\n\n# OR run async with more info\nresponse: Response[FileVolume] = await create_file_volume.asyncio_detailed(client=client, src_format=FileSourceFormat, body=bytes)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.create_file_volume.html"}}, {"op": "add", "path": "/paths/~1file~1volume/post/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1volume/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1volume/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1volume/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1mass/post/x-python", "value": {"example": "from kittycad.models import FileMass\nfrom kittycad.api.file import create_file_mass\nfrom kittycad.types import Response\n\nfc: FileMass = create_file_mass.sync(client=client, material_density=\"\", src_format=FileSourceFormat, body=bytes)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileMass] = create_file_mass.sync_detailed(client=client, material_density=\"\", src_format=FileSourceFormat, body=bytes)\n\n# OR run async\nfc: FileMass = await create_file_mass.asyncio(client=client, material_density=\"\", src_format=FileSourceFormat, body=bytes)\n\n# OR run async with more info\nresponse: Response[FileMass] = await create_file_mass.asyncio_detailed(client=client, material_density=\"\", src_format=FileSourceFormat, body=bytes)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.create_file_mass.html"}}, {"op": "add", "path": "/paths/~1file~1mass/post/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1mass/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1mass/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1mass/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversions~1{id}/get/x-python", "value": {"example": "from kittycad.models import FileConversion\nfrom kittycad.api.file import get_file_conversion_with_base64_helper\nfrom kittycad.types import Response\n\nfc: FileConversion = get_file_conversion_with_base64_helper.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileConversion] = get_file_conversion_with_base64_helper.sync_detailed(client=client, id=)\n\n# OR run async\nfc: FileConversion = await get_file_conversion_with_base64_helper.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[FileConversion] = await get_file_conversion_with_base64_helper.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.get_file_conversion_with_base64_helper.html"}}, {"op": "add", "path": "/paths/~1file~1conversions~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversions~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversions~1{id}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1execute~1{lang}/post/x-python", "value": {"example": "from kittycad.models import CodeOutput\nfrom kittycad.api.file import create_file_execution\nfrom kittycad.types import Response\n\nfc: CodeOutput = create_file_execution.sync(client=client, lang=CodeLanguage, output=, body=bytes)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[CodeOutput] = create_file_execution.sync_detailed(client=client, lang=CodeLanguage, output=, body=bytes)\n\n# OR run async\nfc: CodeOutput = await create_file_execution.asyncio(client=client, lang=CodeLanguage, output=, body=bytes)\n\n# OR run async with more info\nresponse: Response[CodeOutput] = await create_file_execution.asyncio_detailed(client=client, lang=CodeLanguage, output=, body=bytes)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.create_file_execution.html"}}, {"op": "add", "path": "/paths/~1file~1execute~1{lang}/post/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1execute~1{lang}/post/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1execute~1{lang}/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1execute~1{lang}/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversion~1{src_format}~1{output_format}/post/x-python", "value": {"example": "from kittycad.models import FileConversion\nfrom kittycad.api.file import create_file_conversion_with_base64_helper\nfrom kittycad.types import Response\n\nfc: FileConversion = create_file_conversion_with_base64_helper.sync(client=client, output_format=FileOutputFormat, src_format=FileSourceFormat, body=bytes)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileConversion] = create_file_conversion_with_base64_helper.sync_detailed(client=client, output_format=FileOutputFormat, src_format=FileSourceFormat, body=bytes)\n\n# OR run async\nfc: FileConversion = await create_file_conversion_with_base64_helper.asyncio(client=client, output_format=FileOutputFormat, src_format=FileSourceFormat, body=bytes)\n\n# OR run async with more info\nresponse: Response[FileConversion] = await create_file_conversion_with_base64_helper.asyncio_detailed(client=client, output_format=FileOutputFormat, src_format=FileSourceFormat, body=bytes)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.create_file_conversion_with_base64_helper.html"}}, {"op": "add", "path": "/paths/~1file~1conversion~1{src_format}~1{output_format}/post/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversion~1{src_format}~1{output_format}/post/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversion~1{src_format}~1{output_format}/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversion~1{src_format}~1{output_format}/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversion~1{src_format}~1{output_format}/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations~1{id}/get/x-python", "value": {"example": "from kittycad.models import FileConversion\nfrom kittycad.api.api-calls import get_async_operation\nfrom kittycad.types import Response\n\nfc: FileConversion = get_async_operation.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileConversion] = get_async_operation.sync_detailed(client=client, id=)\n\n# OR run async\nfc: FileConversion = await get_async_operation.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[FileConversion] = await get_async_operation.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.get_async_operation.html"}}, {"op": "add", "path": "/paths/~1async~1operations~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations~1{id}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/put/x-python", "value": {"example": "from kittycad.models import User\nfrom kittycad.api.users import update_user_self\nfrom kittycad.types import Response\n\nfc: User = update_user_self.sync(client=client, body=UpdateUser)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[User] = update_user_self.sync_detailed(client=client, body=UpdateUser)\n\n# OR run async\nfc: User = await update_user_self.asyncio(client=client, body=UpdateUser)\n\n# OR run async with more info\nresponse: Response[User] = await update_user_self.asyncio_detailed(client=client, body=UpdateUser)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.update_user_self.html"}}, {"op": "add", "path": "/paths/~1user/put/requestBody/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/put/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/put/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/put/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/options/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/options/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/delete/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.users import delete_user_self\nfrom kittycad.types import Response\n\nfc: Error = delete_user_self.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = delete_user_self.sync_detailed(client=client)\n\n# OR run async\nfc: Error = await delete_user_self.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Error] = await delete_user_self.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.delete_user_self.html"}}, {"op": "add", "path": "/paths/~1user/delete/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/delete/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/get/x-python", "value": {"example": "from kittycad.models import User\nfrom kittycad.api.users import get_user_self\nfrom kittycad.types import Response\n\nfc: User = get_user_self.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[User] = get_user_self.sync_detailed(client=client)\n\n# OR run async\nfc: User = await get_user_self.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[User] = await get_user_self.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.get_user_self.html"}}, {"op": "add", "path": "/paths/~1user/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1token/post/requestBody/content/application~1x-www-form-urlencoded/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1auth/post/requestBody/content/application~1x-www-form-urlencoded/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls/get/x-python", "value": {"example": "from kittycad.models import ApiCallWithPriceResultsPage\nfrom kittycad.api.api-calls import user_list_api_calls\nfrom kittycad.types import Response\n\nfc: ApiCallWithPriceResultsPage = user_list_api_calls.sync(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiCallWithPriceResultsPage] = user_list_api_calls.sync_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async\nfc: ApiCallWithPriceResultsPage = await user_list_api_calls.asyncio(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async with more info\nresponse: Response[ApiCallWithPriceResultsPage] = await user_list_api_calls.asyncio_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.user_list_api_calls.html"}}, {"op": "add", "path": "/paths/~1user~1api-calls/get/parameters/2/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/get/x-python", "value": {"example": "from kittycad.models import ApiTokenResultsPage\nfrom kittycad.api.api-tokens import list_api_tokens_for_user\nfrom kittycad.types import Response\n\nfc: ApiTokenResultsPage = list_api_tokens_for_user.sync(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiTokenResultsPage] = list_api_tokens_for_user.sync_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async\nfc: ApiTokenResultsPage = await list_api_tokens_for_user.asyncio(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async with more info\nresponse: Response[ApiTokenResultsPage] = await list_api_tokens_for_user.asyncio_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-tokens.list_api_tokens_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1api-tokens/get/parameters/2/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/post/x-python", "value": {"example": "from kittycad.models import ApiToken\nfrom kittycad.api.api-tokens import create_api_token_for_user\nfrom kittycad.types import Response\n\nfc: ApiToken = create_api_token_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiToken] = create_api_token_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: ApiToken = await create_api_token_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[ApiToken] = await create_api_token_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-tokens.create_api_token_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1api-tokens/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1intent/post/x-python", "value": {"example": "from kittycad.models import PaymentIntent\nfrom kittycad.api.payments import create_payment_intent_for_user\nfrom kittycad.types import Response\n\nfc: PaymentIntent = create_payment_intent_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[PaymentIntent] = create_payment_intent_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: PaymentIntent = await create_payment_intent_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[PaymentIntent] = await create_payment_intent_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.create_payment_intent_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment~1intent/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1intent/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1intent/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1file~1conversions~1{id}/get/x-python", "value": {"example": "from kittycad.models import FileConversion\nfrom kittycad.api.file import get_file_conversion_for_user\nfrom kittycad.types import Response\n\nfc: FileConversion = get_file_conversion_for_user.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileConversion] = get_file_conversion_for_user.sync_detailed(client=client, id=)\n\n# OR run async\nfc: FileConversion = await get_file_conversion_for_user.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[FileConversion] = await get_file_conversion_for_user.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.get_file_conversion_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1file~1conversions~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1file~1conversions~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1file~1conversions~1{id}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1verify/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1verify/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1_meta~1info/get/x-python", "value": {"example": "from kittycad.models import Metadata\nfrom kittycad.api.meta import get_metadata\nfrom kittycad.types import Response\n\nfc: Metadata = get_metadata.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Metadata] = get_metadata.sync_detailed(client=client)\n\n# OR run async\nfc: Metadata = await get_metadata.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Metadata] = await get_metadata.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.meta.get_metadata.html"}}, {"op": "add", "path": "/paths/~1_meta~1info/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1_meta~1info/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1_meta~1info/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls/get/x-python", "value": {"example": "from kittycad.models import ApiCallWithPriceResultsPage\nfrom kittycad.api.api-calls import list_api_calls\nfrom kittycad.types import Response\n\nfc: ApiCallWithPriceResultsPage = list_api_calls.sync(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiCallWithPriceResultsPage] = list_api_calls.sync_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async\nfc: ApiCallWithPriceResultsPage = await list_api_calls.asyncio(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async with more info\nresponse: Response[ApiCallWithPriceResultsPage] = await list_api_calls.asyncio_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.list_api_calls.html"}}, {"op": "add", "path": "/paths/~1api-calls/get/parameters/2/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}~1api-calls/get/x-python", "value": {"example": "from kittycad.models import ApiCallWithPriceResultsPage\nfrom kittycad.api.api-calls import list_api_calls_for_user\nfrom kittycad.types import Response\n\nfc: ApiCallWithPriceResultsPage = list_api_calls_for_user.sync(client=client, id=, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiCallWithPriceResultsPage] = list_api_calls_for_user.sync_detailed(client=client, id=, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async\nfc: ApiCallWithPriceResultsPage = await list_api_calls_for_user.asyncio(client=client, id=, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async with more info\nresponse: Response[ApiCallWithPriceResultsPage] = await list_api_calls_for_user.asyncio_detailed(client=client, id=, limit=\"\", page_token=, sort_by=CreatedAtSortMode)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.list_api_calls_for_user.html"}}, {"op": "add", "path": "/paths/~1users~1{id}~1api-calls/get/parameters/3/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}~1api-calls/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}~1api-calls/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}~1api-calls/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls~1{id}/get/x-python", "value": {"example": "from kittycad.models import ApiCallWithPrice\nfrom kittycad.api.api-calls import get_api_call\nfrom kittycad.types import Response\n\nfc: ApiCallWithPrice = get_api_call.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiCallWithPrice] = get_api_call.sync_detailed(client=client, id=)\n\n# OR run async\nfc: ApiCallWithPrice = await get_api_call.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[ApiCallWithPrice] = await get_api_call.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.get_api_call.html"}}, {"op": "add", "path": "/paths/~1api-calls~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls~1{id}/get/responses/5XX/x-scope", "value": [""]}] \ No newline at end of file +[{"op": "add", "path": "/components/responses/Error/content/application~1json/schema/x-scope", "value": ["", "#/components/responses/Error"]}, {"op": "add", "path": "/components/schemas/UnitDataConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitDataConversion"]}, {"op": "add", "path": "/components/schemas/UnitDataConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitDataConversion"]}, {"op": "add", "path": "/components/schemas/UnitDataConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitDataConversion"]}, {"op": "add", "path": "/components/schemas/UnitDataConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitDataConversion"]}, {"op": "add", "path": "/components/schemas/UnitDataTransferRateConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitDataTransferRateConversion"]}, {"op": "add", "path": "/components/schemas/UnitDataTransferRateConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitDataTransferRateConversion"]}, {"op": "add", "path": "/components/schemas/UnitDataTransferRateConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitDataTransferRateConversion"]}, {"op": "add", "path": "/components/schemas/UnitDataTransferRateConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitDataTransferRateConversion"]}, {"op": "add", "path": "/components/schemas/Invoice/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/Invoice"]}, {"op": "add", "path": "/components/schemas/Invoice/properties/currency/allOf/0/x-scope", "value": ["", "#/components/schemas/Invoice"]}, {"op": "add", "path": "/components/schemas/Invoice/properties/lines/items/x-scope", "value": ["", "#/components/schemas/Invoice"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/0/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/0/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/0/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/0/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/1/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/1/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/1/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/2/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/2/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/2/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/3/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/3/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallOutput/oneOf/3/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallOutput"]}, {"op": "add", "path": "/components/schemas/FileDensity/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/FileDensity"]}, {"op": "add", "path": "/components/schemas/FileDensity/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/FileDensity"]}, {"op": "add", "path": "/components/schemas/FileDensity/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/FileDensity"]}, {"op": "add", "path": "/components/schemas/UnitChargeConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitChargeConversion"]}, {"op": "add", "path": "/components/schemas/UnitChargeConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitChargeConversion"]}, {"op": "add", "path": "/components/schemas/UnitChargeConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitChargeConversion"]}, {"op": "add", "path": "/components/schemas/UnitChargeConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitChargeConversion"]}, {"op": "add", "path": "/components/schemas/AsyncApiCallResultsPage/properties/items/items/x-scope", "value": ["", "#/components/schemas/AsyncApiCallResultsPage"]}, {"op": "add", "path": "/components/schemas/CustomerBalance/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/CustomerBalance"]}, {"op": "add", "path": "/components/schemas/UnitLengthConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitLengthConversion"]}, {"op": "add", "path": "/components/schemas/UnitLengthConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitLengthConversion"]}, {"op": "add", "path": "/components/schemas/UnitLengthConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitLengthConversion"]}, {"op": "add", "path": "/components/schemas/UnitLengthConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitLengthConversion"]}, {"op": "add", "path": "/components/schemas/UnitVelocityConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitVelocityConversion"]}, {"op": "add", "path": "/components/schemas/UnitVelocityConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitVelocityConversion"]}, {"op": "add", "path": "/components/schemas/UnitVelocityConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitVelocityConversion"]}, {"op": "add", "path": "/components/schemas/UnitVelocityConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitVelocityConversion"]}, {"op": "add", "path": "/components/schemas/UnitAccelerationConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAccelerationConversion"]}, {"op": "add", "path": "/components/schemas/UnitAccelerationConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAccelerationConversion"]}, {"op": "add", "path": "/components/schemas/UnitAccelerationConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAccelerationConversion"]}, {"op": "add", "path": "/components/schemas/UnitAccelerationConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAccelerationConversion"]}, {"op": "add", "path": "/components/schemas/AsyncApiCall/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallResultsPage", "#/components/schemas/AsyncApiCall"]}, {"op": "add", "path": "/components/schemas/AsyncApiCall/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallResultsPage", "#/components/schemas/AsyncApiCall"]}, {"op": "add", "path": "/components/schemas/AsyncApiCall/properties/type/allOf/0/x-scope", "value": ["", "#/components/schemas/AsyncApiCallResultsPage", "#/components/schemas/AsyncApiCall"]}, {"op": "add", "path": "/components/schemas/UnitAngularVelocityConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAngularVelocityConversion"]}, {"op": "add", "path": "/components/schemas/UnitAngularVelocityConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAngularVelocityConversion"]}, {"op": "add", "path": "/components/schemas/UnitAngularVelocityConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAngularVelocityConversion"]}, {"op": "add", "path": "/components/schemas/UnitAngularVelocityConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAngularVelocityConversion"]}, {"op": "add", "path": "/components/schemas/UnitConcentrationConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitConcentrationConversion"]}, {"op": "add", "path": "/components/schemas/UnitConcentrationConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitConcentrationConversion"]}, {"op": "add", "path": "/components/schemas/UnitConcentrationConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitConcentrationConversion"]}, {"op": "add", "path": "/components/schemas/UnitConcentrationConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitConcentrationConversion"]}, {"op": "add", "path": "/components/schemas/UnitForceConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitForceConversion"]}, {"op": "add", "path": "/components/schemas/UnitForceConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitForceConversion"]}, {"op": "add", "path": "/components/schemas/UnitForceConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitForceConversion"]}, {"op": "add", "path": "/components/schemas/UnitForceConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitForceConversion"]}, {"op": "add", "path": "/components/schemas/ExtendedUserResultsPage/properties/items/items/x-scope", "value": ["", "#/components/schemas/ExtendedUserResultsPage"]}, {"op": "add", "path": "/components/schemas/ExecutorMetadata/properties/docker_info/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata"]}, {"op": "add", "path": "/components/schemas/ExecutorMetadata/properties/environment/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata"]}, {"op": "add", "path": "/components/schemas/RegistryServiceConfig/properties/index_configs/additionalProperties/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo", "#/components/schemas/RegistryServiceConfig"]}, {"op": "add", "path": "/components/schemas/FileVolume/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/FileVolume"]}, {"op": "add", "path": "/components/schemas/FileVolume/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/FileVolume"]}, {"op": "add", "path": "/components/schemas/FileVolume/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/FileVolume"]}, {"op": "add", "path": "/components/schemas/UnitDensityConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitDensityConversion"]}, {"op": "add", "path": "/components/schemas/UnitDensityConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitDensityConversion"]}, {"op": "add", "path": "/components/schemas/UnitDensityConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitDensityConversion"]}, {"op": "add", "path": "/components/schemas/UnitDensityConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitDensityConversion"]}, {"op": "add", "path": "/components/schemas/UnitSolidAngleConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitSolidAngleConversion"]}, {"op": "add", "path": "/components/schemas/UnitSolidAngleConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitSolidAngleConversion"]}, {"op": "add", "path": "/components/schemas/UnitSolidAngleConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitSolidAngleConversion"]}, {"op": "add", "path": "/components/schemas/UnitSolidAngleConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitSolidAngleConversion"]}, {"op": "add", "path": "/components/schemas/Jetstream/properties/stats/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata", "#/components/schemas/Connection", "#/components/schemas/Jetstream"]}, {"op": "add", "path": "/components/schemas/Jetstream/properties/config/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata", "#/components/schemas/Connection", "#/components/schemas/Jetstream"]}, {"op": "add", "path": "/components/schemas/Jetstream/properties/meta/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata", "#/components/schemas/Connection", "#/components/schemas/Jetstream"]}, {"op": "add", "path": "/components/schemas/CardDetails/properties/checks/allOf/0/x-scope", "value": ["", "#/components/schemas/PaymentMethod", "#/components/schemas/CardDetails"]}, {"op": "add", "path": "/components/schemas/EngineMetadata/properties/pubsub/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata"]}, {"op": "add", "path": "/components/schemas/EngineMetadata/properties/environment/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata"]}, {"op": "add", "path": "/components/schemas/EngineMetadata/properties/cache/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata"]}, {"op": "add", "path": "/components/schemas/EngineMetadata/properties/fs/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata"]}, {"op": "add", "path": "/components/schemas/UnitMagneticFluxConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMagneticFluxConversion"]}, {"op": "add", "path": "/components/schemas/UnitMagneticFluxConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMagneticFluxConversion"]}, {"op": "add", "path": "/components/schemas/UnitMagneticFluxConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMagneticFluxConversion"]}, {"op": "add", "path": "/components/schemas/UnitMagneticFluxConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMagneticFluxConversion"]}, {"op": "add", "path": "/components/schemas/ApiCallWithPrice/properties/token/allOf/0/x-scope", "value": ["", "#/components/schemas/ApiCallWithPriceResultsPage", "#/components/schemas/ApiCallWithPrice"]}, {"op": "add", "path": "/components/schemas/ApiCallWithPrice/properties/method/allOf/0/x-scope", "value": ["", "#/components/schemas/ApiCallWithPriceResultsPage", "#/components/schemas/ApiCallWithPrice"]}, {"op": "add", "path": "/components/schemas/ApiCallWithPrice/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/ApiCallWithPriceResultsPage", "#/components/schemas/ApiCallWithPrice"]}, {"op": "add", "path": "/components/schemas/UnitPressureConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitPressureConversion"]}, {"op": "add", "path": "/components/schemas/UnitPressureConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitPressureConversion"]}, {"op": "add", "path": "/components/schemas/UnitPressureConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitPressureConversion"]}, {"op": "add", "path": "/components/schemas/UnitPressureConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitPressureConversion"]}, {"op": "add", "path": "/components/schemas/Customer/properties/currency/allOf/0/x-scope", "value": ["", "#/components/schemas/Customer"]}, {"op": "add", "path": "/components/schemas/Customer/properties/address/allOf/0/x-scope", "value": ["", "#/components/schemas/Customer"]}, {"op": "add", "path": "/components/schemas/DeviceAccessTokenRequestForm/properties/grant_type/allOf/0/x-scope", "value": ["", "#/components/schemas/DeviceAccessTokenRequestForm"]}, {"op": "add", "path": "/components/schemas/UserResultsPage/properties/items/items/x-scope", "value": ["", "#/components/schemas/UserResultsPage"]}, {"op": "add", "path": "/components/schemas/Metadata/properties/engine/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata"]}, {"op": "add", "path": "/components/schemas/Metadata/properties/pubsub/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata"]}, {"op": "add", "path": "/components/schemas/Metadata/properties/environment/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata"]}, {"op": "add", "path": "/components/schemas/Metadata/properties/executor/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata"]}, {"op": "add", "path": "/components/schemas/Metadata/properties/cache/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata"]}, {"op": "add", "path": "/components/schemas/Metadata/properties/fs/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata"]}, {"op": "add", "path": "/components/schemas/ApiCallWithPriceResultsPage/properties/items/items/x-scope", "value": ["", "#/components/schemas/ApiCallWithPriceResultsPage"]}, {"op": "add", "path": "/components/schemas/ApiToken/properties/token/allOf/0/x-scope", "value": ["", "#/components/schemas/ApiTokenResultsPage", "#/components/schemas/ApiToken"]}, {"op": "add", "path": "/components/schemas/UnitMagneticFieldStrengthConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMagneticFieldStrengthConversion"]}, {"op": "add", "path": "/components/schemas/UnitMagneticFieldStrengthConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMagneticFieldStrengthConversion"]}, {"op": "add", "path": "/components/schemas/UnitMagneticFieldStrengthConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMagneticFieldStrengthConversion"]}, {"op": "add", "path": "/components/schemas/UnitMagneticFieldStrengthConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMagneticFieldStrengthConversion"]}, {"op": "add", "path": "/components/schemas/UnitEnergyConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitEnergyConversion"]}, {"op": "add", "path": "/components/schemas/UnitEnergyConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitEnergyConversion"]}, {"op": "add", "path": "/components/schemas/UnitEnergyConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitEnergyConversion"]}, {"op": "add", "path": "/components/schemas/UnitEnergyConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitEnergyConversion"]}, {"op": "add", "path": "/components/schemas/JetstreamStats/properties/api/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata", "#/components/schemas/Connection", "#/components/schemas/Jetstream", "#/components/schemas/JetstreamStats"]}, {"op": "add", "path": "/components/schemas/UnitVoltageConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitVoltageConversion"]}, {"op": "add", "path": "/components/schemas/UnitVoltageConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitVoltageConversion"]}, {"op": "add", "path": "/components/schemas/UnitVoltageConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitVoltageConversion"]}, {"op": "add", "path": "/components/schemas/UnitVoltageConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitVoltageConversion"]}, {"op": "add", "path": "/components/schemas/UnitMassConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMassConversion"]}, {"op": "add", "path": "/components/schemas/UnitMassConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMassConversion"]}, {"op": "add", "path": "/components/schemas/UnitMassConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMassConversion"]}, {"op": "add", "path": "/components/schemas/UnitMassConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMassConversion"]}, {"op": "add", "path": "/components/schemas/ApiTokenResultsPage/properties/items/items/x-scope", "value": ["", "#/components/schemas/ApiTokenResultsPage"]}, {"op": "add", "path": "/components/schemas/UnitMetricConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMetricConversion"]}, {"op": "add", "path": "/components/schemas/UnitMetricConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMetricConversion"]}, {"op": "add", "path": "/components/schemas/UnitMetricConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMetricConversion"]}, {"op": "add", "path": "/components/schemas/UnitMetricConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitMetricConversion"]}, {"op": "add", "path": "/components/schemas/CodeOutput/properties/output_files/items/x-scope", "value": ["", "#/components/schemas/CodeOutput"]}, {"op": "add", "path": "/components/schemas/UnitTimeConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitTimeConversion"]}, {"op": "add", "path": "/components/schemas/UnitTimeConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitTimeConversion"]}, {"op": "add", "path": "/components/schemas/UnitTimeConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitTimeConversion"]}, {"op": "add", "path": "/components/schemas/UnitTimeConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitTimeConversion"]}, {"op": "add", "path": "/components/schemas/BillingInfo/properties/address/allOf/0/x-scope", "value": ["", "#/components/schemas/BillingInfo"]}, {"op": "add", "path": "/components/schemas/UnitIlluminanceConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitIlluminanceConversion"]}, {"op": "add", "path": "/components/schemas/UnitIlluminanceConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitIlluminanceConversion"]}, {"op": "add", "path": "/components/schemas/UnitIlluminanceConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitIlluminanceConversion"]}, {"op": "add", "path": "/components/schemas/UnitIlluminanceConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitIlluminanceConversion"]}, {"op": "add", "path": "/components/schemas/Address/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/Customer", "#/components/schemas/Address"]}, {"op": "add", "path": "/components/schemas/UnitAreaConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAreaConversion"]}, {"op": "add", "path": "/components/schemas/UnitAreaConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAreaConversion"]}, {"op": "add", "path": "/components/schemas/UnitAreaConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAreaConversion"]}, {"op": "add", "path": "/components/schemas/UnitAreaConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAreaConversion"]}, {"op": "add", "path": "/components/schemas/FileConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/FileConversion"]}, {"op": "add", "path": "/components/schemas/FileConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/FileConversion"]}, {"op": "add", "path": "/components/schemas/FileConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/FileConversion"]}, {"op": "add", "path": "/components/schemas/FileConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/FileConversion"]}, {"op": "add", "path": "/components/schemas/UnitTemperatureConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitTemperatureConversion"]}, {"op": "add", "path": "/components/schemas/UnitTemperatureConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitTemperatureConversion"]}, {"op": "add", "path": "/components/schemas/UnitTemperatureConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitTemperatureConversion"]}, {"op": "add", "path": "/components/schemas/UnitTemperatureConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitTemperatureConversion"]}, {"op": "add", "path": "/components/schemas/UnitPowerConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitPowerConversion"]}, {"op": "add", "path": "/components/schemas/UnitPowerConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitPowerConversion"]}, {"op": "add", "path": "/components/schemas/UnitPowerConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitPowerConversion"]}, {"op": "add", "path": "/components/schemas/UnitPowerConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitPowerConversion"]}, {"op": "add", "path": "/components/schemas/InvoiceLineItem/properties/currency/allOf/0/x-scope", "value": ["", "#/components/schemas/Invoice", "#/components/schemas/InvoiceLineItem"]}, {"op": "add", "path": "/components/schemas/PaymentMethod/properties/card/allOf/0/x-scope", "value": ["", "#/components/schemas/PaymentMethod"]}, {"op": "add", "path": "/components/schemas/PaymentMethod/properties/billing_info/allOf/0/x-scope", "value": ["", "#/components/schemas/PaymentMethod"]}, {"op": "add", "path": "/components/schemas/PaymentMethod/properties/type/allOf/0/x-scope", "value": ["", "#/components/schemas/PaymentMethod"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/default_address_pools/items/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/cgroup_driver/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/runtimes/additionalProperties/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/isolation/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/runc_commit/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/plugins/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/cgroup_version/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/init_commit/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/containerd_commit/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/DockerSystemInfo/properties/registry_config/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/ExecutorMetadata", "#/components/schemas/DockerSystemInfo"]}, {"op": "add", "path": "/components/schemas/UnitVolumeConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitVolumeConversion"]}, {"op": "add", "path": "/components/schemas/UnitVolumeConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitVolumeConversion"]}, {"op": "add", "path": "/components/schemas/UnitVolumeConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitVolumeConversion"]}, {"op": "add", "path": "/components/schemas/UnitVolumeConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitVolumeConversion"]}, {"op": "add", "path": "/components/schemas/Session/properties/session_token/allOf/0/x-scope", "value": ["", "#/components/schemas/Session"]}, {"op": "add", "path": "/components/schemas/UnitRadiationConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitRadiationConversion"]}, {"op": "add", "path": "/components/schemas/UnitRadiationConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitRadiationConversion"]}, {"op": "add", "path": "/components/schemas/UnitRadiationConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitRadiationConversion"]}, {"op": "add", "path": "/components/schemas/UnitRadiationConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitRadiationConversion"]}, {"op": "add", "path": "/components/schemas/Connection/properties/leaf/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata", "#/components/schemas/Connection"]}, {"op": "add", "path": "/components/schemas/Connection/properties/gateway/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata", "#/components/schemas/Connection"]}, {"op": "add", "path": "/components/schemas/Connection/properties/cluster/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata", "#/components/schemas/Connection"]}, {"op": "add", "path": "/components/schemas/Connection/properties/jetstream/allOf/0/x-scope", "value": ["", "#/components/schemas/Metadata", "#/components/schemas/EngineMetadata", "#/components/schemas/Connection"]}, {"op": "add", "path": "/components/schemas/FileMass/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/FileMass"]}, {"op": "add", "path": "/components/schemas/FileMass/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/FileMass"]}, {"op": "add", "path": "/components/schemas/FileMass/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/FileMass"]}, {"op": "add", "path": "/components/schemas/UnitAngleConversion/properties/output_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAngleConversion"]}, {"op": "add", "path": "/components/schemas/UnitAngleConversion/properties/src_format/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAngleConversion"]}, {"op": "add", "path": "/components/schemas/UnitAngleConversion/properties/id/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAngleConversion"]}, {"op": "add", "path": "/components/schemas/UnitAngleConversion/properties/status/allOf/0/x-scope", "value": ["", "#/components/schemas/UnitAngleConversion"]}, {"op": "add", "path": "/info/x-python", "value": {"client": "# Create a client with your token.\nfrom kittycad import Client\n\nclient = Client(token=\"$TOKEN\")\n\n# - OR -\n\n# Create a new client with your token parsed from the environment variable:\n# `KITTYCAD_API_TOKEN`.\nfrom kittycad import ClientFromEnv\n\nclient = ClientFromEnv()", "install": "pip install kittycad"}}, {"op": "add", "path": "/paths/~1user~1payment~1intent/post/x-python", "value": {"example": "from kittycad.models import PaymentIntent\nfrom kittycad.api.payments import create_payment_intent_for_user\nfrom kittycad.types import Response\n\nfc: PaymentIntent = create_payment_intent_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[PaymentIntent] = create_payment_intent_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: PaymentIntent = await create_payment_intent_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[PaymentIntent] = await create_payment_intent_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.create_payment_intent_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment~1intent/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1intent/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1intent/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1volume~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitVolumeConversion\nfrom kittycad.api.unit import get_volume_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitVolumeConversion = get_volume_unit_conversion.sync(client=client, output_format=UnitVolumeFormat, src_format=UnitVolumeFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitVolumeConversion] = get_volume_unit_conversion.sync_detailed(client=client, output_format=UnitVolumeFormat, src_format=UnitVolumeFormat, value=\"\")\n\n# OR run async\nfc: UnitVolumeConversion = await get_volume_unit_conversion.asyncio(client=client, output_format=UnitVolumeFormat, src_format=UnitVolumeFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitVolumeConversion] = await get_volume_unit_conversion.asyncio_detailed(client=client, output_format=UnitVolumeFormat, src_format=UnitVolumeFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_volume_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1volume~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1volume~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1volume~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1volume~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1volume~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations/get/x-python", "value": {"example": "from kittycad.models import AsyncApiCallResultsPage\nfrom kittycad.api.api-calls import list_async_operations\nfrom kittycad.types import Response\n\nfc: AsyncApiCallResultsPage = list_async_operations.sync(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode, status=ApiCallStatus)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[AsyncApiCallResultsPage] = list_async_operations.sync_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode, status=ApiCallStatus)\n\n# OR run async\nfc: AsyncApiCallResultsPage = await list_async_operations.asyncio(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode, status=ApiCallStatus)\n\n# OR run async with more info\nresponse: Response[AsyncApiCallResultsPage] = await list_async_operations.asyncio_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode, status=ApiCallStatus)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.list_async_operations.html"}}, {"op": "add", "path": "/paths/~1async~1operations/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations/get/parameters/2/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations/get/parameters/3/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1pressure~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitPressureConversion\nfrom kittycad.api.unit import get_pressure_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitPressureConversion = get_pressure_unit_conversion.sync(client=client, output_format=UnitPressureFormat, src_format=UnitPressureFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitPressureConversion] = get_pressure_unit_conversion.sync_detailed(client=client, output_format=UnitPressureFormat, src_format=UnitPressureFormat, value=\"\")\n\n# OR run async\nfc: UnitPressureConversion = await get_pressure_unit_conversion.asyncio(client=client, output_format=UnitPressureFormat, src_format=UnitPressureFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitPressureConversion] = await get_pressure_unit_conversion.asyncio_detailed(client=client, output_format=UnitPressureFormat, src_format=UnitPressureFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_pressure_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1pressure~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1pressure~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1pressure~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1pressure~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1pressure~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversions~1{id}/get/x-python", "value": {"example": "from kittycad.models import FileConversion\nfrom kittycad.api.file import get_file_conversion_with_base64_helper\nfrom kittycad.types import Response\n\nfc: FileConversion = get_file_conversion_with_base64_helper.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileConversion] = get_file_conversion_with_base64_helper.sync_detailed(client=client, id=)\n\n# OR run async\nfc: FileConversion = await get_file_conversion_with_base64_helper.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[FileConversion] = await get_file_conversion_with_base64_helper.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.get_file_conversion_with_base64_helper.html"}}, {"op": "add", "path": "/paths/~1file~1conversions~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversions~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversions~1{id}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/put/x-python", "value": {"example": "from kittycad.models import User\nfrom kittycad.api.users import update_user_self\nfrom kittycad.types import Response\n\nfc: User = update_user_self.sync(client=client, body=UpdateUser)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[User] = update_user_self.sync_detailed(client=client, body=UpdateUser)\n\n# OR run async\nfc: User = await update_user_self.asyncio(client=client, body=UpdateUser)\n\n# OR run async with more info\nresponse: Response[User] = await update_user_self.asyncio_detailed(client=client, body=UpdateUser)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.update_user_self.html"}}, {"op": "add", "path": "/paths/~1user/put/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/put/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/put/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/put/requestBody/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/get/x-python", "value": {"example": "from kittycad.models import User\nfrom kittycad.api.users import get_user_self\nfrom kittycad.types import Response\n\nfc: User = get_user_self.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[User] = get_user_self.sync_detailed(client=client)\n\n# OR run async\nfc: User = await get_user_self.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[User] = await get_user_self.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.get_user_self.html"}}, {"op": "add", "path": "/paths/~1user/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/delete/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.users import delete_user_self\nfrom kittycad.types import Response\n\nfc: Error = delete_user_self.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = delete_user_self.sync_detailed(client=client)\n\n# OR run async\nfc: Error = await delete_user_self.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Error] = await delete_user_self.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.delete_user_self.html"}}, {"op": "add", "path": "/paths/~1user/delete/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/delete/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/options/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user/options/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1ping/get/x-python", "value": {"example": "from kittycad.models import Pong\nfrom kittycad.api.meta import ping\nfrom kittycad.types import Response\n\nfc: Pong = ping.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Pong] = ping.sync_detailed(client=client)\n\n# OR run async\nfc: Pong = await ping.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Pong] = await ping.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.meta.ping.html"}}, {"op": "add", "path": "/paths/~1ping/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1ping/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1ping/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1apps~1github~1consent/get/x-python", "value": {"example": "from kittycad.models import AppClientInfo\nfrom kittycad.api.apps import apps_github_consent\nfrom kittycad.types import Response\n\nfc: AppClientInfo = apps_github_consent.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[AppClientInfo] = apps_github_consent.sync_detailed(client=client)\n\n# OR run async\nfc: AppClientInfo = await apps_github_consent.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[AppClientInfo] = await apps_github_consent.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.apps.apps_github_consent.html"}}, {"op": "add", "path": "/paths/~1apps~1github~1consent/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1apps~1github~1consent/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1apps~1github~1consent/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1/get/x-python", "value": {"example": "from kittycad.models import dict\nfrom kittycad.api.meta import get_schema\nfrom kittycad.types import Response\n\nfc: dict = get_schema.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[dict] = get_schema.sync_detailed(client=client)\n\n# OR run async\nfc: dict = await get_schema.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[dict] = await get_schema.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.meta.get_schema.html"}}, {"op": "add", "path": "/paths/~1/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1apps~1github~1webhook/post/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.apps import apps_github_webhook\nfrom kittycad.types import Response\n\nfc: Error = apps_github_webhook.sync(client=client, body=bytes)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = apps_github_webhook.sync_detailed(client=client, body=bytes)\n\n# OR run async\nfc: Error = await apps_github_webhook.asyncio(client=client, body=bytes)\n\n# OR run async with more info\nresponse: Response[Error] = await apps_github_webhook.asyncio_detailed(client=client, body=bytes)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.apps.apps_github_webhook.html"}}, {"op": "add", "path": "/paths/~1apps~1github~1webhook/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1apps~1github~1webhook/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1mass~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitMassConversion\nfrom kittycad.api.unit import get_mass_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitMassConversion = get_mass_unit_conversion.sync(client=client, output_format=UnitMassFormat, src_format=UnitMassFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitMassConversion] = get_mass_unit_conversion.sync_detailed(client=client, output_format=UnitMassFormat, src_format=UnitMassFormat, value=\"\")\n\n# OR run async\nfc: UnitMassConversion = await get_mass_unit_conversion.asyncio(client=client, output_format=UnitMassFormat, src_format=UnitMassFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitMassConversion] = await get_mass_unit_conversion.asyncio_detailed(client=client, output_format=UnitMassFormat, src_format=UnitMassFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_mass_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1mass~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1mass~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1mass~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1mass~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1mass~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/delete/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.payments import delete_payment_information_for_user\nfrom kittycad.types import Response\n\nfc: Error = delete_payment_information_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = delete_payment_information_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: Error = await delete_payment_information_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Error] = await delete_payment_information_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.delete_payment_information_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment/delete/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/delete/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/post/x-python", "value": {"example": "from kittycad.models import Customer\nfrom kittycad.api.payments import create_payment_information_for_user\nfrom kittycad.types import Response\n\nfc: Customer = create_payment_information_for_user.sync(client=client, body=BillingInfo)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Customer] = create_payment_information_for_user.sync_detailed(client=client, body=BillingInfo)\n\n# OR run async\nfc: Customer = await create_payment_information_for_user.asyncio(client=client, body=BillingInfo)\n\n# OR run async with more info\nresponse: Response[Customer] = await create_payment_information_for_user.asyncio_detailed(client=client, body=BillingInfo)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.create_payment_information_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/post/requestBody/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/put/x-python", "value": {"example": "from kittycad.models import Customer\nfrom kittycad.api.payments import update_payment_information_for_user\nfrom kittycad.types import Response\n\nfc: Customer = update_payment_information_for_user.sync(client=client, body=BillingInfo)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Customer] = update_payment_information_for_user.sync_detailed(client=client, body=BillingInfo)\n\n# OR run async\nfc: Customer = await update_payment_information_for_user.asyncio(client=client, body=BillingInfo)\n\n# OR run async with more info\nresponse: Response[Customer] = await update_payment_information_for_user.asyncio_detailed(client=client, body=BillingInfo)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.update_payment_information_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment/put/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/put/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/put/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/put/requestBody/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/options/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/options/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/get/x-python", "value": {"example": "from kittycad.models import Customer\nfrom kittycad.api.payments import get_payment_information_for_user\nfrom kittycad.types import Response\n\nfc: Customer = get_payment_information_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Customer] = get_payment_information_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: Customer = await get_payment_information_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Customer] = await get_payment_information_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.get_payment_information_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}/get/x-python", "value": {"example": "from kittycad.models import User\nfrom kittycad.api.users import get_user\nfrom kittycad.types import Response\n\nfc: User = get_user.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[User] = get_user.sync_detailed(client=client, id=)\n\n# OR run async\nfc: User = await get_user.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[User] = await get_user.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.get_user.html"}}, {"op": "add", "path": "/paths/~1users~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1area~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitAreaConversion\nfrom kittycad.api.unit import get_area_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitAreaConversion = get_area_unit_conversion.sync(client=client, output_format=UnitAreaFormat, src_format=UnitAreaFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitAreaConversion] = get_area_unit_conversion.sync_detailed(client=client, output_format=UnitAreaFormat, src_format=UnitAreaFormat, value=\"\")\n\n# OR run async\nfc: UnitAreaConversion = await get_area_unit_conversion.asyncio(client=client, output_format=UnitAreaFormat, src_format=UnitAreaFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitAreaConversion] = await get_area_unit_conversion.asyncio_detailed(client=client, output_format=UnitAreaFormat, src_format=UnitAreaFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_area_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1area~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1area~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1area~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1area~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1area~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1force~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitForceConversion\nfrom kittycad.api.unit import get_force_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitForceConversion = get_force_unit_conversion.sync(client=client, output_format=UnitForceFormat, src_format=UnitForceFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitForceConversion] = get_force_unit_conversion.sync_detailed(client=client, output_format=UnitForceFormat, src_format=UnitForceFormat, value=\"\")\n\n# OR run async\nfc: UnitForceConversion = await get_force_unit_conversion.asyncio(client=client, output_format=UnitForceFormat, src_format=UnitForceFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitForceConversion] = await get_force_unit_conversion.asyncio_detailed(client=client, output_format=UnitForceFormat, src_format=UnitForceFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_force_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1force~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1force~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1force~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1force~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1force~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1execute~1{lang}/post/x-python", "value": {"example": "from kittycad.models import CodeOutput\nfrom kittycad.api.file import create_file_execution\nfrom kittycad.types import Response\n\nfc: CodeOutput = create_file_execution.sync(client=client, lang=CodeLanguage, output=, body=bytes)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[CodeOutput] = create_file_execution.sync_detailed(client=client, lang=CodeLanguage, output=, body=bytes)\n\n# OR run async\nfc: CodeOutput = await create_file_execution.asyncio(client=client, lang=CodeLanguage, output=, body=bytes)\n\n# OR run async with more info\nresponse: Response[CodeOutput] = await create_file_execution.asyncio_detailed(client=client, lang=CodeLanguage, output=, body=bytes)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.create_file_execution.html"}}, {"op": "add", "path": "/paths/~1file~1execute~1{lang}/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1execute~1{lang}/post/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1execute~1{lang}/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1execute~1{lang}/post/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1consent/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1consent/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1consent/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1consent/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1methods~1{id}/delete/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.payments import delete_payment_method_for_user\nfrom kittycad.types import Response\n\nfc: Error = delete_payment_method_for_user.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = delete_payment_method_for_user.sync_detailed(client=client, id=)\n\n# OR run async\nfc: Error = await delete_payment_method_for_user.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[Error] = await delete_payment_method_for_user.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.delete_payment_method_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment~1methods~1{id}/delete/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1methods~1{id}/delete/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1methods~1{id}/options/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1methods~1{id}/options/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-call-metrics/get/x-python", "value": {"example": "from kittycad.models import [ApiCallQueryGroup]\nfrom kittycad.api.api-calls import get_api_call_metrics\nfrom kittycad.types import Response\n\nfc: [ApiCallQueryGroup] = get_api_call_metrics.sync(client=client, group_by=ApiCallQueryGroupBy)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[[ApiCallQueryGroup]] = get_api_call_metrics.sync_detailed(client=client, group_by=ApiCallQueryGroupBy)\n\n# OR run async\nfc: [ApiCallQueryGroup] = await get_api_call_metrics.asyncio(client=client, group_by=ApiCallQueryGroupBy)\n\n# OR run async with more info\nresponse: Response[[ApiCallQueryGroup]] = await get_api_call_metrics.asyncio_detailed(client=client, group_by=ApiCallQueryGroupBy)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.get_api_call_metrics.html"}}, {"op": "add", "path": "/paths/~1api-call-metrics/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-call-metrics/get/responses/200/content/application~1json/schema/items/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-call-metrics/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-call-metrics/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1extended/get/x-python", "value": {"example": "from kittycad.models import ExtendedUser\nfrom kittycad.api.users import get_user_self_extended\nfrom kittycad.types import Response\n\nfc: ExtendedUser = get_user_self_extended.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ExtendedUser] = get_user_self_extended.sync_detailed(client=client)\n\n# OR run async\nfc: ExtendedUser = await get_user_self_extended.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[ExtendedUser] = await get_user_self_extended.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.get_user_self_extended.html"}}, {"op": "add", "path": "/paths/~1user~1extended/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1extended/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1extended/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1balance/get/x-python", "value": {"example": "from kittycad.models import CustomerBalance\nfrom kittycad.api.payments import get_payment_balance_for_user\nfrom kittycad.types import Response\n\nfc: CustomerBalance = get_payment_balance_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[CustomerBalance] = get_payment_balance_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: CustomerBalance = await get_payment_balance_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[CustomerBalance] = await get_payment_balance_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.get_payment_balance_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment~1balance/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1balance/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1balance/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/get/x-python", "value": {"example": "from kittycad.models import ApiToken\nfrom kittycad.api.api-tokens import get_api_token_for_user\nfrom kittycad.types import Response\n\nfc: ApiToken = get_api_token_for_user.sync(client=client, token=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiToken] = get_api_token_for_user.sync_detailed(client=client, token=\"\")\n\n# OR run async\nfc: ApiToken = await get_api_token_for_user.asyncio(client=client, token=\"\")\n\n# OR run async with more info\nresponse: Response[ApiToken] = await get_api_token_for_user.asyncio_detailed(client=client, token=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-tokens.get_api_token_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/delete/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.api-tokens import delete_api_token_for_user\nfrom kittycad.types import Response\n\nfc: Error = delete_api_token_for_user.sync(client=client, token=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = delete_api_token_for_user.sync_detailed(client=client, token=\"\")\n\n# OR run async\nfc: Error = await delete_api_token_for_user.asyncio(client=client, token=\"\")\n\n# OR run async with more info\nresponse: Response[Error] = await delete_api_token_for_user.asyncio_detailed(client=client, token=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-tokens.delete_api_token_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/delete/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/delete/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/options/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens~1{token}/options/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1energy~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitEnergyConversion\nfrom kittycad.api.unit import get_energy_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitEnergyConversion = get_energy_unit_conversion.sync(client=client, output_format=UnitEnergyFormat, src_format=UnitEnergyFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitEnergyConversion] = get_energy_unit_conversion.sync_detailed(client=client, output_format=UnitEnergyFormat, src_format=UnitEnergyFormat, value=\"\")\n\n# OR run async\nfc: UnitEnergyConversion = await get_energy_unit_conversion.asyncio(client=client, output_format=UnitEnergyFormat, src_format=UnitEnergyFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitEnergyConversion] = await get_energy_unit_conversion.asyncio_detailed(client=client, output_format=UnitEnergyFormat, src_format=UnitEnergyFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_energy_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1energy~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1energy~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1energy~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1energy~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1energy~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1auth/post/requestBody/content/application~1x-www-form-urlencoded/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1verify/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1verify/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1density~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitDensityConversion\nfrom kittycad.api.unit import get_density_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitDensityConversion = get_density_unit_conversion.sync(client=client, output_format=UnitDensityFormat, src_format=UnitDensityFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitDensityConversion] = get_density_unit_conversion.sync_detailed(client=client, output_format=UnitDensityFormat, src_format=UnitDensityFormat, value=\"\")\n\n# OR run async\nfc: UnitDensityConversion = await get_density_unit_conversion.asyncio(client=client, output_format=UnitDensityFormat, src_format=UnitDensityFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitDensityConversion] = await get_density_unit_conversion.asyncio_detailed(client=client, output_format=UnitDensityFormat, src_format=UnitDensityFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_density_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1density~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1density~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1density~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1density~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1density~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls~1{id}/get/x-python", "value": {"example": "from kittycad.models import ApiCallWithPrice\nfrom kittycad.api.api-calls import get_api_call_for_user\nfrom kittycad.types import Response\n\nfc: ApiCallWithPrice = get_api_call_for_user.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiCallWithPrice] = get_api_call_for_user.sync_detailed(client=client, id=)\n\n# OR run async\nfc: ApiCallWithPrice = await get_api_call_for_user.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[ApiCallWithPrice] = await get_api_call_for_user.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.get_api_call_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1api-calls~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls~1{id}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1_meta~1info/get/x-python", "value": {"example": "from kittycad.models import Metadata\nfrom kittycad.api.meta import get_metadata\nfrom kittycad.types import Response\n\nfc: Metadata = get_metadata.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Metadata] = get_metadata.sync_detailed(client=client)\n\n# OR run async\nfc: Metadata = await get_metadata.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Metadata] = await get_metadata.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.meta.get_metadata.html"}}, {"op": "add", "path": "/paths/~1_meta~1info/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1_meta~1info/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1_meta~1info/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations~1{id}/get/x-python", "value": {"example": "from kittycad.models import FileConversion\nfrom kittycad.api.api-calls import get_async_operation\nfrom kittycad.types import Response\n\nfc: FileConversion = get_async_operation.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileConversion] = get_async_operation.sync_detailed(client=client, id=)\n\n# OR run async\nfc: FileConversion = await get_async_operation.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[FileConversion] = await get_async_operation.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.get_async_operation.html"}}, {"op": "add", "path": "/paths/~1async~1operations~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1async~1operations~1{id}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1magnetic-field-strength~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitMagneticFieldStrengthConversion\nfrom kittycad.api.unit import get_magnetic_field_strength_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitMagneticFieldStrengthConversion = get_magnetic_field_strength_unit_conversion.sync(client=client, output_format=UnitMagneticFieldStrengthFormat, src_format=UnitMagneticFieldStrengthFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitMagneticFieldStrengthConversion] = get_magnetic_field_strength_unit_conversion.sync_detailed(client=client, output_format=UnitMagneticFieldStrengthFormat, src_format=UnitMagneticFieldStrengthFormat, value=\"\")\n\n# OR run async\nfc: UnitMagneticFieldStrengthConversion = await get_magnetic_field_strength_unit_conversion.asyncio(client=client, output_format=UnitMagneticFieldStrengthFormat, src_format=UnitMagneticFieldStrengthFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitMagneticFieldStrengthConversion] = await get_magnetic_field_strength_unit_conversion.asyncio_detailed(client=client, output_format=UnitMagneticFieldStrengthFormat, src_format=UnitMagneticFieldStrengthFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_magnetic_field_strength_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1magnetic-field-strength~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1magnetic-field-strength~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1magnetic-field-strength~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1magnetic-field-strength~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1magnetic-field-strength~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1methods/get/x-python", "value": {"example": "from kittycad.models import [PaymentMethod]\nfrom kittycad.api.payments import list_payment_methods_for_user\nfrom kittycad.types import Response\n\nfc: [PaymentMethod] = list_payment_methods_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[[PaymentMethod]] = list_payment_methods_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: [PaymentMethod] = await list_payment_methods_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[[PaymentMethod]] = await list_payment_methods_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.list_payment_methods_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment~1methods/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1methods/get/responses/200/content/application~1json/schema/items/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1methods/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1voltage~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitVoltageConversion\nfrom kittycad.api.unit import get_voltage_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitVoltageConversion = get_voltage_unit_conversion.sync(client=client, output_format=UnitVoltageFormat, src_format=UnitVoltageFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitVoltageConversion] = get_voltage_unit_conversion.sync_detailed(client=client, output_format=UnitVoltageFormat, src_format=UnitVoltageFormat, value=\"\")\n\n# OR run async\nfc: UnitVoltageConversion = await get_voltage_unit_conversion.asyncio(client=client, output_format=UnitVoltageFormat, src_format=UnitVoltageFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitVoltageConversion] = await get_voltage_unit_conversion.asyncio_detailed(client=client, output_format=UnitVoltageFormat, src_format=UnitVoltageFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_voltage_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1voltage~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1voltage~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1voltage~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1voltage~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1voltage~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1magnetic-flux~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitMagneticFluxConversion\nfrom kittycad.api.unit import get_magnetic_flux_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitMagneticFluxConversion = get_magnetic_flux_unit_conversion.sync(client=client, output_format=UnitMagneticFluxFormat, src_format=UnitMagneticFluxFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitMagneticFluxConversion] = get_magnetic_flux_unit_conversion.sync_detailed(client=client, output_format=UnitMagneticFluxFormat, src_format=UnitMagneticFluxFormat, value=\"\")\n\n# OR run async\nfc: UnitMagneticFluxConversion = await get_magnetic_flux_unit_conversion.asyncio(client=client, output_format=UnitMagneticFluxFormat, src_format=UnitMagneticFluxFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitMagneticFluxConversion] = await get_magnetic_flux_unit_conversion.asyncio_detailed(client=client, output_format=UnitMagneticFluxFormat, src_format=UnitMagneticFluxFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_magnetic_flux_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1magnetic-flux~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1magnetic-flux~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1magnetic-flux~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1magnetic-flux~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1magnetic-flux~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1metric~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitMetricConversion\nfrom kittycad.api.unit import get_metric_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitMetricConversion = get_metric_unit_conversion.sync(client=client, output_format=UnitMetricFormat, src_format=UnitMetricFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitMetricConversion] = get_metric_unit_conversion.sync_detailed(client=client, output_format=UnitMetricFormat, src_format=UnitMetricFormat, value=\"\")\n\n# OR run async\nfc: UnitMetricConversion = await get_metric_unit_conversion.asyncio(client=client, output_format=UnitMetricFormat, src_format=UnitMetricFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitMetricConversion] = await get_metric_unit_conversion.asyncio_detailed(client=client, output_format=UnitMetricFormat, src_format=UnitMetricFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_metric_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1metric~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1metric~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1metric~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1metric~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1metric~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1radiation~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitRadiationConversion\nfrom kittycad.api.unit import get_radiation_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitRadiationConversion = get_radiation_unit_conversion.sync(client=client, output_format=UnitRadiationFormat, src_format=UnitRadiationFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitRadiationConversion] = get_radiation_unit_conversion.sync_detailed(client=client, output_format=UnitRadiationFormat, src_format=UnitRadiationFormat, value=\"\")\n\n# OR run async\nfc: UnitRadiationConversion = await get_radiation_unit_conversion.asyncio(client=client, output_format=UnitRadiationFormat, src_format=UnitRadiationFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitRadiationConversion] = await get_radiation_unit_conversion.asyncio_detailed(client=client, output_format=UnitRadiationFormat, src_format=UnitRadiationFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_radiation_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1radiation~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1radiation~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1radiation~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1radiation~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1radiation~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended~1{id}/get/x-python", "value": {"example": "from kittycad.models import ExtendedUser\nfrom kittycad.api.users import get_user_extended\nfrom kittycad.types import Response\n\nfc: ExtendedUser = get_user_extended.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ExtendedUser] = get_user_extended.sync_detailed(client=client, id=)\n\n# OR run async\nfc: ExtendedUser = await get_user_extended.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[ExtendedUser] = await get_user_extended.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.get_user_extended.html"}}, {"op": "add", "path": "/paths/~1users-extended~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended~1{id}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversion~1{src_format}~1{output_format}/post/x-python", "value": {"example": "from kittycad.models import FileConversion\nfrom kittycad.api.file import create_file_conversion_with_base64_helper\nfrom kittycad.types import Response\n\nfc: FileConversion = create_file_conversion_with_base64_helper.sync(client=client, output_format=FileOutputFormat, src_format=FileSourceFormat, body=bytes)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileConversion] = create_file_conversion_with_base64_helper.sync_detailed(client=client, output_format=FileOutputFormat, src_format=FileSourceFormat, body=bytes)\n\n# OR run async\nfc: FileConversion = await create_file_conversion_with_base64_helper.asyncio(client=client, output_format=FileOutputFormat, src_format=FileSourceFormat, body=bytes)\n\n# OR run async with more info\nresponse: Response[FileConversion] = await create_file_conversion_with_base64_helper.asyncio_detailed(client=client, output_format=FileOutputFormat, src_format=FileSourceFormat, body=bytes)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.create_file_conversion_with_base64_helper.html"}}, {"op": "add", "path": "/paths/~1file~1conversion~1{src_format}~1{output_format}/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversion~1{src_format}~1{output_format}/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversion~1{src_format}~1{output_format}/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversion~1{src_format}~1{output_format}/post/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1conversion~1{src_format}~1{output_format}/post/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/get/x-python", "value": {"example": "from kittycad.models import ApiTokenResultsPage\nfrom kittycad.api.api-tokens import list_api_tokens_for_user\nfrom kittycad.types import Response\n\nfc: ApiTokenResultsPage = list_api_tokens_for_user.sync(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiTokenResultsPage] = list_api_tokens_for_user.sync_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async\nfc: ApiTokenResultsPage = await list_api_tokens_for_user.asyncio(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async with more info\nresponse: Response[ApiTokenResultsPage] = await list_api_tokens_for_user.asyncio_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-tokens.list_api_tokens_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1api-tokens/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/get/parameters/2/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/post/x-python", "value": {"example": "from kittycad.models import ApiToken\nfrom kittycad.api.api-tokens import create_api_token_for_user\nfrom kittycad.types import Response\n\nfc: ApiToken = create_api_token_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiToken] = create_api_token_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: ApiToken = await create_api_token_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[ApiToken] = await create_api_token_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-tokens.create_api_token_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1api-tokens/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-tokens/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1solid-angle~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitSolidAngleConversion\nfrom kittycad.api.unit import get_solid_angle_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitSolidAngleConversion = get_solid_angle_unit_conversion.sync(client=client, output_format=UnitSolidAngleFormat, src_format=UnitSolidAngleFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitSolidAngleConversion] = get_solid_angle_unit_conversion.sync_detailed(client=client, output_format=UnitSolidAngleFormat, src_format=UnitSolidAngleFormat, value=\"\")\n\n# OR run async\nfc: UnitSolidAngleConversion = await get_solid_angle_unit_conversion.asyncio(client=client, output_format=UnitSolidAngleFormat, src_format=UnitSolidAngleFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitSolidAngleConversion] = await get_solid_angle_unit_conversion.asyncio_detailed(client=client, output_format=UnitSolidAngleFormat, src_format=UnitSolidAngleFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_solid_angle_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1solid-angle~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1solid-angle~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1solid-angle~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1solid-angle~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1solid-angle~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1time~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitTimeConversion\nfrom kittycad.api.unit import get_time_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitTimeConversion = get_time_unit_conversion.sync(client=client, output_format=UnitTimeFormat, src_format=UnitTimeFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitTimeConversion] = get_time_unit_conversion.sync_detailed(client=client, output_format=UnitTimeFormat, src_format=UnitTimeFormat, value=\"\")\n\n# OR run async\nfc: UnitTimeConversion = await get_time_unit_conversion.asyncio(client=client, output_format=UnitTimeFormat, src_format=UnitTimeFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitTimeConversion] = await get_time_unit_conversion.asyncio_detailed(client=client, output_format=UnitTimeFormat, src_format=UnitTimeFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_time_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1time~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1time~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1time~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1time~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1time~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1length~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitLengthConversion\nfrom kittycad.api.unit import get_length_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitLengthConversion = get_length_unit_conversion.sync(client=client, output_format=UnitLengthFormat, src_format=UnitLengthFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitLengthConversion] = get_length_unit_conversion.sync_detailed(client=client, output_format=UnitLengthFormat, src_format=UnitLengthFormat, value=\"\")\n\n# OR run async\nfc: UnitLengthConversion = await get_length_unit_conversion.asyncio(client=client, output_format=UnitLengthFormat, src_format=UnitLengthFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitLengthConversion] = await get_length_unit_conversion.asyncio_detailed(client=client, output_format=UnitLengthFormat, src_format=UnitLengthFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_length_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1length~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1length~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1length~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1length~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1length~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1density/post/x-python", "value": {"example": "from kittycad.models import FileDensity\nfrom kittycad.api.file import create_file_density\nfrom kittycad.types import Response\n\nfc: FileDensity = create_file_density.sync(client=client, material_mass=\"\", src_format=FileSourceFormat, body=bytes)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileDensity] = create_file_density.sync_detailed(client=client, material_mass=\"\", src_format=FileSourceFormat, body=bytes)\n\n# OR run async\nfc: FileDensity = await create_file_density.asyncio(client=client, material_mass=\"\", src_format=FileSourceFormat, body=bytes)\n\n# OR run async with more info\nresponse: Response[FileDensity] = await create_file_density.asyncio_detailed(client=client, material_mass=\"\", src_format=FileSourceFormat, body=bytes)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.create_file_density.html"}}, {"op": "add", "path": "/paths/~1file~1density/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1density/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1density/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1density/post/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1velocity~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitVelocityConversion\nfrom kittycad.api.unit import get_velocity_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitVelocityConversion = get_velocity_unit_conversion.sync(client=client, output_format=UnitVelocityFormat, src_format=UnitVelocityFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitVelocityConversion] = get_velocity_unit_conversion.sync_detailed(client=client, output_format=UnitVelocityFormat, src_format=UnitVelocityFormat, value=\"\")\n\n# OR run async\nfc: UnitVelocityConversion = await get_velocity_unit_conversion.asyncio(client=client, output_format=UnitVelocityFormat, src_format=UnitVelocityFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitVelocityConversion] = await get_velocity_unit_conversion.asyncio_detailed(client=client, output_format=UnitVelocityFormat, src_format=UnitVelocityFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_velocity_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1velocity~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1velocity~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1velocity~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1velocity~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1velocity~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended/get/x-python", "value": {"example": "from kittycad.models import ExtendedUserResultsPage\nfrom kittycad.api.users import list_users_extended\nfrom kittycad.types import Response\n\nfc: ExtendedUserResultsPage = list_users_extended.sync(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ExtendedUserResultsPage] = list_users_extended.sync_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async\nfc: ExtendedUserResultsPage = await list_users_extended.asyncio(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async with more info\nresponse: Response[ExtendedUserResultsPage] = await list_users_extended.asyncio_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.list_users_extended.html"}}, {"op": "add", "path": "/paths/~1users-extended/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users-extended/get/parameters/2/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1apps~1github~1callback/get/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.apps import apps_github_callback\nfrom kittycad.types import Response\n\nfc: Error = apps_github_callback.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = apps_github_callback.sync_detailed(client=client)\n\n# OR run async\nfc: Error = await apps_github_callback.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Error] = await apps_github_callback.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.apps.apps_github_callback.html"}}, {"op": "add", "path": "/paths/~1apps~1github~1callback/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1apps~1github~1callback/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1angular-velocity~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitAngularVelocityConversion\nfrom kittycad.api.unit import get_angular_velocity_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitAngularVelocityConversion = get_angular_velocity_unit_conversion.sync(client=client, output_format=UnitAngularVelocityFormat, src_format=UnitAngularVelocityFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitAngularVelocityConversion] = get_angular_velocity_unit_conversion.sync_detailed(client=client, output_format=UnitAngularVelocityFormat, src_format=UnitAngularVelocityFormat, value=\"\")\n\n# OR run async\nfc: UnitAngularVelocityConversion = await get_angular_velocity_unit_conversion.asyncio(client=client, output_format=UnitAngularVelocityFormat, src_format=UnitAngularVelocityFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitAngularVelocityConversion] = await get_angular_velocity_unit_conversion.asyncio_detailed(client=client, output_format=UnitAngularVelocityFormat, src_format=UnitAngularVelocityFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_angular_velocity_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1angular-velocity~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1angular-velocity~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1angular-velocity~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1angular-velocity~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1angular-velocity~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1illuminance~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitIlluminanceConversion\nfrom kittycad.api.unit import get_illuminance_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitIlluminanceConversion = get_illuminance_unit_conversion.sync(client=client, output_format=UnitIlluminanceFormat, src_format=UnitIlluminanceFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitIlluminanceConversion] = get_illuminance_unit_conversion.sync_detailed(client=client, output_format=UnitIlluminanceFormat, src_format=UnitIlluminanceFormat, value=\"\")\n\n# OR run async\nfc: UnitIlluminanceConversion = await get_illuminance_unit_conversion.asyncio(client=client, output_format=UnitIlluminanceFormat, src_format=UnitIlluminanceFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitIlluminanceConversion] = await get_illuminance_unit_conversion.asyncio_detailed(client=client, output_format=UnitIlluminanceFormat, src_format=UnitIlluminanceFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_illuminance_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1illuminance~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1illuminance~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1illuminance~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1illuminance~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1illuminance~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1mass/post/x-python", "value": {"example": "from kittycad.models import FileMass\nfrom kittycad.api.file import create_file_mass\nfrom kittycad.types import Response\n\nfc: FileMass = create_file_mass.sync(client=client, material_density=\"\", src_format=FileSourceFormat, body=bytes)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileMass] = create_file_mass.sync_detailed(client=client, material_density=\"\", src_format=FileSourceFormat, body=bytes)\n\n# OR run async\nfc: FileMass = await create_file_mass.asyncio(client=client, material_density=\"\", src_format=FileSourceFormat, body=bytes)\n\n# OR run async with more info\nresponse: Response[FileMass] = await create_file_mass.asyncio_detailed(client=client, material_density=\"\", src_format=FileSourceFormat, body=bytes)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.create_file_mass.html"}}, {"op": "add", "path": "/paths/~1file~1mass/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1mass/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1mass/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1mass/post/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls~1{id}/get/x-python", "value": {"example": "from kittycad.models import ApiCallWithPrice\nfrom kittycad.api.api-calls import get_api_call\nfrom kittycad.types import Response\n\nfc: ApiCallWithPrice = get_api_call.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiCallWithPrice] = get_api_call.sync_detailed(client=client, id=)\n\n# OR run async\nfc: ApiCallWithPrice = await get_api_call.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[ApiCallWithPrice] = await get_api_call.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.get_api_call.html"}}, {"op": "add", "path": "/paths/~1api-calls~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls~1{id}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls/get/x-python", "value": {"example": "from kittycad.models import ApiCallWithPriceResultsPage\nfrom kittycad.api.api-calls import list_api_calls\nfrom kittycad.types import Response\n\nfc: ApiCallWithPriceResultsPage = list_api_calls.sync(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiCallWithPriceResultsPage] = list_api_calls.sync_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async\nfc: ApiCallWithPriceResultsPage = await list_api_calls.asyncio(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async with more info\nresponse: Response[ApiCallWithPriceResultsPage] = await list_api_calls.asyncio_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.list_api_calls.html"}}, {"op": "add", "path": "/paths/~1api-calls/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1api-calls/get/parameters/2/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1callback/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1callback/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1provider~1{provider}~1callback/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email~1callback/get/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.hidden import auth_email_callback\nfrom kittycad.types import Response\n\nfc: Error = auth_email_callback.sync(client=client, callback_url=\"\", email=\"\", token=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = auth_email_callback.sync_detailed(client=client, callback_url=\"\", email=\"\", token=)\n\n# OR run async\nfc: Error = await auth_email_callback.asyncio(client=client, callback_url=\"\", email=\"\", token=)\n\n# OR run async with more info\nresponse: Response[Error] = await auth_email_callback.asyncio_detailed(client=client, callback_url=\"\", email=\"\", token=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.hidden.auth_email_callback.html"}}, {"op": "add", "path": "/paths/~1auth~1email~1callback/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email~1callback/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}~1api-calls/get/x-python", "value": {"example": "from kittycad.models import ApiCallWithPriceResultsPage\nfrom kittycad.api.api-calls import list_api_calls_for_user\nfrom kittycad.types import Response\n\nfc: ApiCallWithPriceResultsPage = list_api_calls_for_user.sync(client=client, id=, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiCallWithPriceResultsPage] = list_api_calls_for_user.sync_detailed(client=client, id=, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async\nfc: ApiCallWithPriceResultsPage = await list_api_calls_for_user.asyncio(client=client, id=, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async with more info\nresponse: Response[ApiCallWithPriceResultsPage] = await list_api_calls_for_user.asyncio_detailed(client=client, id=, limit=\"\", page_token=, sort_by=CreatedAtSortMode)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.list_api_calls_for_user.html"}}, {"op": "add", "path": "/paths/~1users~1{id}~1api-calls/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}~1api-calls/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}~1api-calls/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users~1{id}~1api-calls/get/parameters/3/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1invoices/get/x-python", "value": {"example": "from kittycad.models import [Invoice]\nfrom kittycad.api.payments import list_invoices_for_user\nfrom kittycad.types import Response\n\nfc: [Invoice] = list_invoices_for_user.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[[Invoice]] = list_invoices_for_user.sync_detailed(client=client)\n\n# OR run async\nfc: [Invoice] = await list_invoices_for_user.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[[Invoice]] = await list_invoices_for_user.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.payments.list_invoices_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1payment~1invoices/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1invoices/get/responses/200/content/application~1json/schema/items/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1payment~1invoices/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1confirm/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1confirm/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1confirm/post/requestBody/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1confirm/options/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1confirm/options/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1session~1{token}/get/x-python", "value": {"example": "from kittycad.models import Session\nfrom kittycad.api.sessions import get_session_for_user\nfrom kittycad.types import Response\n\nfc: Session = get_session_for_user.sync(client=client, token=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Session] = get_session_for_user.sync_detailed(client=client, token=\"\")\n\n# OR run async\nfc: Session = await get_session_for_user.asyncio(client=client, token=\"\")\n\n# OR run async with more info\nresponse: Response[Session] = await get_session_for_user.asyncio_detailed(client=client, token=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.sessions.get_session_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1session~1{token}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1session~1{token}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1session~1{token}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1volume/post/x-python", "value": {"example": "from kittycad.models import FileVolume\nfrom kittycad.api.file import create_file_volume\nfrom kittycad.types import Response\n\nfc: FileVolume = create_file_volume.sync(client=client, src_format=FileSourceFormat, body=bytes)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileVolume] = create_file_volume.sync_detailed(client=client, src_format=FileSourceFormat, body=bytes)\n\n# OR run async\nfc: FileVolume = await create_file_volume.asyncio(client=client, src_format=FileSourceFormat, body=bytes)\n\n# OR run async with more info\nresponse: Response[FileVolume] = await create_file_volume.asyncio_detailed(client=client, src_format=FileSourceFormat, body=bytes)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.create_file_volume.html"}}, {"op": "add", "path": "/paths/~1file~1volume/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1volume/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1volume/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1file~1volume/post/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1logout/post/x-python", "value": {"example": "from kittycad.models import Error\nfrom kittycad.api.hidden import logout\nfrom kittycad.types import Response\n\nfc: Error = logout.sync(client=client)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[Error] = logout.sync_detailed(client=client)\n\n# OR run async\nfc: Error = await logout.asyncio(client=client)\n\n# OR run async with more info\nresponse: Response[Error] = await logout.asyncio_detailed(client=client)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.hidden.logout.html"}}, {"op": "add", "path": "/paths/~1logout/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1logout/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1oauth2~1device~1token/post/requestBody/content/application~1x-www-form-urlencoded/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1data-transfer-rate~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitDataTransferRateConversion\nfrom kittycad.api.unit import get_data_transfer_rate_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitDataTransferRateConversion = get_data_transfer_rate_unit_conversion.sync(client=client, output_format=UnitDataTransferRateFormat, src_format=UnitDataTransferRateFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitDataTransferRateConversion] = get_data_transfer_rate_unit_conversion.sync_detailed(client=client, output_format=UnitDataTransferRateFormat, src_format=UnitDataTransferRateFormat, value=\"\")\n\n# OR run async\nfc: UnitDataTransferRateConversion = await get_data_transfer_rate_unit_conversion.asyncio(client=client, output_format=UnitDataTransferRateFormat, src_format=UnitDataTransferRateFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitDataTransferRateConversion] = await get_data_transfer_rate_unit_conversion.asyncio_detailed(client=client, output_format=UnitDataTransferRateFormat, src_format=UnitDataTransferRateFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_data_transfer_rate_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1data-transfer-rate~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1data-transfer-rate~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1data-transfer-rate~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1data-transfer-rate~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1data-transfer-rate~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1power~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitPowerConversion\nfrom kittycad.api.unit import get_power_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitPowerConversion = get_power_unit_conversion.sync(client=client, output_format=UnitPowerFormat, src_format=UnitPowerFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitPowerConversion] = get_power_unit_conversion.sync_detailed(client=client, output_format=UnitPowerFormat, src_format=UnitPowerFormat, value=\"\")\n\n# OR run async\nfc: UnitPowerConversion = await get_power_unit_conversion.asyncio(client=client, output_format=UnitPowerFormat, src_format=UnitPowerFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitPowerConversion] = await get_power_unit_conversion.asyncio_detailed(client=client, output_format=UnitPowerFormat, src_format=UnitPowerFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_power_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1power~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1power~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1power~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1power~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1power~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1data~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitDataConversion\nfrom kittycad.api.unit import get_data_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitDataConversion = get_data_unit_conversion.sync(client=client, output_format=UnitDataFormat, src_format=UnitDataFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitDataConversion] = get_data_unit_conversion.sync_detailed(client=client, output_format=UnitDataFormat, src_format=UnitDataFormat, value=\"\")\n\n# OR run async\nfc: UnitDataConversion = await get_data_unit_conversion.asyncio(client=client, output_format=UnitDataFormat, src_format=UnitDataFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitDataConversion] = await get_data_unit_conversion.asyncio_detailed(client=client, output_format=UnitDataFormat, src_format=UnitDataFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_data_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1data~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1data~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1data~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1data~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1data~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1temperature~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitTemperatureConversion\nfrom kittycad.api.unit import get_temperature_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitTemperatureConversion = get_temperature_unit_conversion.sync(client=client, output_format=UnitTemperatureFormat, src_format=UnitTemperatureFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitTemperatureConversion] = get_temperature_unit_conversion.sync_detailed(client=client, output_format=UnitTemperatureFormat, src_format=UnitTemperatureFormat, value=\"\")\n\n# OR run async\nfc: UnitTemperatureConversion = await get_temperature_unit_conversion.asyncio(client=client, output_format=UnitTemperatureFormat, src_format=UnitTemperatureFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitTemperatureConversion] = await get_temperature_unit_conversion.asyncio_detailed(client=client, output_format=UnitTemperatureFormat, src_format=UnitTemperatureFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_temperature_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1temperature~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1temperature~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1temperature~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1temperature~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1temperature~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1acceleration~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitAccelerationConversion\nfrom kittycad.api.unit import get_acceleration_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitAccelerationConversion = get_acceleration_unit_conversion.sync(client=client, output_format=UnitAccelerationFormat, src_format=UnitAccelerationFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitAccelerationConversion] = get_acceleration_unit_conversion.sync_detailed(client=client, output_format=UnitAccelerationFormat, src_format=UnitAccelerationFormat, value=\"\")\n\n# OR run async\nfc: UnitAccelerationConversion = await get_acceleration_unit_conversion.asyncio(client=client, output_format=UnitAccelerationFormat, src_format=UnitAccelerationFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitAccelerationConversion] = await get_acceleration_unit_conversion.asyncio_detailed(client=client, output_format=UnitAccelerationFormat, src_format=UnitAccelerationFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_acceleration_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1acceleration~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1acceleration~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1acceleration~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1acceleration~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1acceleration~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1charge~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitChargeConversion\nfrom kittycad.api.unit import get_charge_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitChargeConversion = get_charge_unit_conversion.sync(client=client, output_format=UnitChargeFormat, src_format=UnitChargeFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitChargeConversion] = get_charge_unit_conversion.sync_detailed(client=client, output_format=UnitChargeFormat, src_format=UnitChargeFormat, value=\"\")\n\n# OR run async\nfc: UnitChargeConversion = await get_charge_unit_conversion.asyncio(client=client, output_format=UnitChargeFormat, src_format=UnitChargeFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitChargeConversion] = await get_charge_unit_conversion.asyncio_detailed(client=client, output_format=UnitChargeFormat, src_format=UnitChargeFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_charge_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1charge~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1charge~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1charge~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1charge~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1charge~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users/get/x-python", "value": {"example": "from kittycad.models import UserResultsPage\nfrom kittycad.api.users import list_users\nfrom kittycad.types import Response\n\nfc: UserResultsPage = list_users.sync(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UserResultsPage] = list_users.sync_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async\nfc: UserResultsPage = await list_users.asyncio(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async with more info\nresponse: Response[UserResultsPage] = await list_users.asyncio_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.users.list_users.html"}}, {"op": "add", "path": "/paths/~1users/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1users/get/parameters/2/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1file~1conversions~1{id}/get/x-python", "value": {"example": "from kittycad.models import FileConversion\nfrom kittycad.api.file import get_file_conversion_for_user\nfrom kittycad.types import Response\n\nfc: FileConversion = get_file_conversion_for_user.sync(client=client, id=)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[FileConversion] = get_file_conversion_for_user.sync_detailed(client=client, id=)\n\n# OR run async\nfc: FileConversion = await get_file_conversion_for_user.asyncio(client=client, id=)\n\n# OR run async with more info\nresponse: Response[FileConversion] = await get_file_conversion_for_user.asyncio_detailed(client=client, id=)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.file.get_file_conversion_for_user.html"}}, {"op": "add", "path": "/paths/~1user~1file~1conversions~1{id}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1file~1conversions~1{id}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1file~1conversions~1{id}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1concentration~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitConcentrationConversion\nfrom kittycad.api.unit import get_concentration_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitConcentrationConversion = get_concentration_unit_conversion.sync(client=client, output_format=UnitConcentrationFormat, src_format=UnitConcentrationFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitConcentrationConversion] = get_concentration_unit_conversion.sync_detailed(client=client, output_format=UnitConcentrationFormat, src_format=UnitConcentrationFormat, value=\"\")\n\n# OR run async\nfc: UnitConcentrationConversion = await get_concentration_unit_conversion.asyncio(client=client, output_format=UnitConcentrationFormat, src_format=UnitConcentrationFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitConcentrationConversion] = await get_concentration_unit_conversion.asyncio_detailed(client=client, output_format=UnitConcentrationFormat, src_format=UnitConcentrationFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_concentration_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1concentration~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1concentration~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1concentration~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1concentration~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1concentration~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls/get/x-python", "value": {"example": "from kittycad.models import ApiCallWithPriceResultsPage\nfrom kittycad.api.api-calls import user_list_api_calls\nfrom kittycad.types import Response\n\nfc: ApiCallWithPriceResultsPage = user_list_api_calls.sync(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[ApiCallWithPriceResultsPage] = user_list_api_calls.sync_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async\nfc: ApiCallWithPriceResultsPage = await user_list_api_calls.asyncio(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)\n\n# OR run async with more info\nresponse: Response[ApiCallWithPriceResultsPage] = await user_list_api_calls.asyncio_detailed(client=client, limit=\"\", page_token=, sort_by=CreatedAtSortMode)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.api-calls.user_list_api_calls.html"}}, {"op": "add", "path": "/paths/~1user~1api-calls/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1user~1api-calls/get/parameters/2/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1angle~1{src_format}~1{output_format}/get/x-python", "value": {"example": "from kittycad.models import UnitAngleConversion\nfrom kittycad.api.unit import get_angle_unit_conversion\nfrom kittycad.types import Response\n\nfc: UnitAngleConversion = get_angle_unit_conversion.sync(client=client, output_format=UnitAngleFormat, src_format=UnitAngleFormat, value=\"\")\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[UnitAngleConversion] = get_angle_unit_conversion.sync_detailed(client=client, output_format=UnitAngleFormat, src_format=UnitAngleFormat, value=\"\")\n\n# OR run async\nfc: UnitAngleConversion = await get_angle_unit_conversion.asyncio(client=client, output_format=UnitAngleFormat, src_format=UnitAngleFormat, value=\"\")\n\n# OR run async with more info\nresponse: Response[UnitAngleConversion] = await get_angle_unit_conversion.asyncio_detailed(client=client, output_format=UnitAngleFormat, src_format=UnitAngleFormat, value=\"\")", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.unit.get_angle_unit_conversion.html"}}, {"op": "add", "path": "/paths/~1unit~1conversion~1angle~1{src_format}~1{output_format}/get/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1angle~1{src_format}~1{output_format}/get/responses/200/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1angle~1{src_format}~1{output_format}/get/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1angle~1{src_format}~1{output_format}/get/parameters/0/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1unit~1conversion~1angle~1{src_format}~1{output_format}/get/parameters/1/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email/post/x-python", "value": {"example": "from kittycad.models import VerificationToken\nfrom kittycad.api.hidden import auth_email\nfrom kittycad.types import Response\n\nfc: VerificationToken = auth_email.sync(client=client, body=EmailAuthenticationForm)\n\n# OR if you need more info (e.g. status_code)\nresponse: Response[VerificationToken] = auth_email.sync_detailed(client=client, body=EmailAuthenticationForm)\n\n# OR run async\nfc: VerificationToken = await auth_email.asyncio(client=client, body=EmailAuthenticationForm)\n\n# OR run async with more info\nresponse: Response[VerificationToken] = await auth_email.asyncio_detailed(client=client, body=EmailAuthenticationForm)", "libDocsLink": "https://python.api.docs.kittycad.io/modules/kittycad.api.hidden.auth_email.html"}}, {"op": "add", "path": "/paths/~1auth~1email/post/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email/post/responses/201/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email/post/responses/5XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email/post/requestBody/content/application~1json/schema/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email/options/responses/4XX/x-scope", "value": [""]}, {"op": "add", "path": "/paths/~1auth~1email/options/responses/5XX/x-scope", "value": [""]}] \ No newline at end of file diff --git a/kittycad/api/apps/apps_github_webhook.py b/kittycad/api/apps/apps_github_webhook.py new file mode 100644 index 000000000..37a6b45f8 --- /dev/null +++ b/kittycad/api/apps/apps_github_webhook.py @@ -0,0 +1,109 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.error import Error +from ...types import Response + +def _get_kwargs( + body: bytes, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/apps/github/webhook".format(client.base_url) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + "content": body, + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, Error]]: + if response.status_code == 204: + response_204 = None + return response_204 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + body: bytes, + *, + client: Client, +) -> Response[Union[Any, Error]]: + kwargs = _get_kwargs( + body=body, + client=client, + ) + + response = httpx.post( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + body: bytes, + *, + client: Client, +) -> Optional[Union[Any, Error]]: + """ These come from the GitHub app. """ + + return sync_detailed( + body=body, + client=client, + ).parsed + + +async def asyncio_detailed( + body: bytes, + *, + client: Client, +) -> Response[Union[Any, Error]]: + kwargs = _get_kwargs( + body=body, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.post(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + body: bytes, + *, + client: Client, +) -> Optional[Union[Any, Error]]: + """ These come from the GitHub app. """ + + return ( + await asyncio_detailed( + body=body, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_acceleration_unit_conversion.py b/kittycad/api/unit/get_acceleration_unit_conversion.py new file mode 100644 index 000000000..274d8db99 --- /dev/null +++ b/kittycad/api/unit/get_acceleration_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_acceleration_conversion import UnitAccelerationConversion +from ...models.error import Error +from ...models.unit_acceleration_format import UnitAccelerationFormat +from ...models.unit_acceleration_format import UnitAccelerationFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitAccelerationFormat, + src_format: UnitAccelerationFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/acceleration/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitAccelerationConversion, Error]]: + if response.status_code == 200: + response_200 = UnitAccelerationConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitAccelerationConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitAccelerationFormat, + src_format: UnitAccelerationFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitAccelerationConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitAccelerationFormat, + src_format: UnitAccelerationFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitAccelerationConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitAccelerationFormat, + src_format: UnitAccelerationFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitAccelerationConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitAccelerationFormat, + src_format: UnitAccelerationFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitAccelerationConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_angle_unit_conversion.py b/kittycad/api/unit/get_angle_unit_conversion.py new file mode 100644 index 000000000..508e0666d --- /dev/null +++ b/kittycad/api/unit/get_angle_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_angle_conversion import UnitAngleConversion +from ...models.error import Error +from ...models.unit_angle_format import UnitAngleFormat +from ...models.unit_angle_format import UnitAngleFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitAngleFormat, + src_format: UnitAngleFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/angle/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitAngleConversion, Error]]: + if response.status_code == 200: + response_200 = UnitAngleConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitAngleConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitAngleFormat, + src_format: UnitAngleFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitAngleConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitAngleFormat, + src_format: UnitAngleFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitAngleConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitAngleFormat, + src_format: UnitAngleFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitAngleConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitAngleFormat, + src_format: UnitAngleFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitAngleConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_angular_velocity_unit_conversion.py b/kittycad/api/unit/get_angular_velocity_unit_conversion.py new file mode 100644 index 000000000..73c44b30d --- /dev/null +++ b/kittycad/api/unit/get_angular_velocity_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_angular_velocity_conversion import UnitAngularVelocityConversion +from ...models.error import Error +from ...models.unit_angular_velocity_format import UnitAngularVelocityFormat +from ...models.unit_angular_velocity_format import UnitAngularVelocityFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitAngularVelocityFormat, + src_format: UnitAngularVelocityFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/angular-velocity/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitAngularVelocityConversion, Error]]: + if response.status_code == 200: + response_200 = UnitAngularVelocityConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitAngularVelocityConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitAngularVelocityFormat, + src_format: UnitAngularVelocityFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitAngularVelocityConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitAngularVelocityFormat, + src_format: UnitAngularVelocityFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitAngularVelocityConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitAngularVelocityFormat, + src_format: UnitAngularVelocityFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitAngularVelocityConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitAngularVelocityFormat, + src_format: UnitAngularVelocityFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitAngularVelocityConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_area_unit_conversion.py b/kittycad/api/unit/get_area_unit_conversion.py new file mode 100644 index 000000000..95cae0b8b --- /dev/null +++ b/kittycad/api/unit/get_area_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_area_conversion import UnitAreaConversion +from ...models.error import Error +from ...models.unit_area_format import UnitAreaFormat +from ...models.unit_area_format import UnitAreaFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitAreaFormat, + src_format: UnitAreaFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/area/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitAreaConversion, Error]]: + if response.status_code == 200: + response_200 = UnitAreaConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitAreaConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitAreaFormat, + src_format: UnitAreaFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitAreaConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitAreaFormat, + src_format: UnitAreaFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitAreaConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitAreaFormat, + src_format: UnitAreaFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitAreaConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitAreaFormat, + src_format: UnitAreaFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitAreaConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_charge_unit_conversion.py b/kittycad/api/unit/get_charge_unit_conversion.py new file mode 100644 index 000000000..211dbb5f3 --- /dev/null +++ b/kittycad/api/unit/get_charge_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_charge_conversion import UnitChargeConversion +from ...models.error import Error +from ...models.unit_charge_format import UnitChargeFormat +from ...models.unit_charge_format import UnitChargeFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitChargeFormat, + src_format: UnitChargeFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/charge/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitChargeConversion, Error]]: + if response.status_code == 200: + response_200 = UnitChargeConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitChargeConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitChargeFormat, + src_format: UnitChargeFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitChargeConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitChargeFormat, + src_format: UnitChargeFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitChargeConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitChargeFormat, + src_format: UnitChargeFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitChargeConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitChargeFormat, + src_format: UnitChargeFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitChargeConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_concentration_unit_conversion.py b/kittycad/api/unit/get_concentration_unit_conversion.py new file mode 100644 index 000000000..78c9b9c57 --- /dev/null +++ b/kittycad/api/unit/get_concentration_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_concentration_conversion import UnitConcentrationConversion +from ...models.error import Error +from ...models.unit_concentration_format import UnitConcentrationFormat +from ...models.unit_concentration_format import UnitConcentrationFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitConcentrationFormat, + src_format: UnitConcentrationFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/concentration/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitConcentrationConversion, Error]]: + if response.status_code == 200: + response_200 = UnitConcentrationConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitConcentrationConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitConcentrationFormat, + src_format: UnitConcentrationFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitConcentrationConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitConcentrationFormat, + src_format: UnitConcentrationFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitConcentrationConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitConcentrationFormat, + src_format: UnitConcentrationFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitConcentrationConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitConcentrationFormat, + src_format: UnitConcentrationFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitConcentrationConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_data_transfer_rate_unit_conversion.py b/kittycad/api/unit/get_data_transfer_rate_unit_conversion.py new file mode 100644 index 000000000..d463fee3a --- /dev/null +++ b/kittycad/api/unit/get_data_transfer_rate_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_data_transfer_rate_conversion import UnitDataTransferRateConversion +from ...models.error import Error +from ...models.unit_data_transfer_rate_format import UnitDataTransferRateFormat +from ...models.unit_data_transfer_rate_format import UnitDataTransferRateFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitDataTransferRateFormat, + src_format: UnitDataTransferRateFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/data-transfer-rate/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitDataTransferRateConversion, Error]]: + if response.status_code == 200: + response_200 = UnitDataTransferRateConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitDataTransferRateConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitDataTransferRateFormat, + src_format: UnitDataTransferRateFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitDataTransferRateConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitDataTransferRateFormat, + src_format: UnitDataTransferRateFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitDataTransferRateConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitDataTransferRateFormat, + src_format: UnitDataTransferRateFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitDataTransferRateConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitDataTransferRateFormat, + src_format: UnitDataTransferRateFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitDataTransferRateConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_data_unit_conversion.py b/kittycad/api/unit/get_data_unit_conversion.py new file mode 100644 index 000000000..535a5de8e --- /dev/null +++ b/kittycad/api/unit/get_data_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_data_conversion import UnitDataConversion +from ...models.error import Error +from ...models.unit_data_format import UnitDataFormat +from ...models.unit_data_format import UnitDataFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitDataFormat, + src_format: UnitDataFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/data/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitDataConversion, Error]]: + if response.status_code == 200: + response_200 = UnitDataConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitDataConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitDataFormat, + src_format: UnitDataFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitDataConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitDataFormat, + src_format: UnitDataFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitDataConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitDataFormat, + src_format: UnitDataFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitDataConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitDataFormat, + src_format: UnitDataFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitDataConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_density_unit_conversion.py b/kittycad/api/unit/get_density_unit_conversion.py new file mode 100644 index 000000000..9ab907e95 --- /dev/null +++ b/kittycad/api/unit/get_density_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_density_conversion import UnitDensityConversion +from ...models.error import Error +from ...models.unit_density_format import UnitDensityFormat +from ...models.unit_density_format import UnitDensityFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitDensityFormat, + src_format: UnitDensityFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/density/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitDensityConversion, Error]]: + if response.status_code == 200: + response_200 = UnitDensityConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitDensityConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitDensityFormat, + src_format: UnitDensityFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitDensityConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitDensityFormat, + src_format: UnitDensityFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitDensityConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitDensityFormat, + src_format: UnitDensityFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitDensityConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitDensityFormat, + src_format: UnitDensityFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitDensityConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_energy_unit_conversion.py b/kittycad/api/unit/get_energy_unit_conversion.py new file mode 100644 index 000000000..7f8165a45 --- /dev/null +++ b/kittycad/api/unit/get_energy_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_energy_conversion import UnitEnergyConversion +from ...models.error import Error +from ...models.unit_energy_format import UnitEnergyFormat +from ...models.unit_energy_format import UnitEnergyFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitEnergyFormat, + src_format: UnitEnergyFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/energy/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitEnergyConversion, Error]]: + if response.status_code == 200: + response_200 = UnitEnergyConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitEnergyConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitEnergyFormat, + src_format: UnitEnergyFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitEnergyConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitEnergyFormat, + src_format: UnitEnergyFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitEnergyConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitEnergyFormat, + src_format: UnitEnergyFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitEnergyConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitEnergyFormat, + src_format: UnitEnergyFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitEnergyConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_force_unit_conversion.py b/kittycad/api/unit/get_force_unit_conversion.py new file mode 100644 index 000000000..c497d5ea8 --- /dev/null +++ b/kittycad/api/unit/get_force_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_force_conversion import UnitForceConversion +from ...models.error import Error +from ...models.unit_force_format import UnitForceFormat +from ...models.unit_force_format import UnitForceFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitForceFormat, + src_format: UnitForceFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/force/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitForceConversion, Error]]: + if response.status_code == 200: + response_200 = UnitForceConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitForceConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitForceFormat, + src_format: UnitForceFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitForceConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitForceFormat, + src_format: UnitForceFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitForceConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitForceFormat, + src_format: UnitForceFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitForceConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitForceFormat, + src_format: UnitForceFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitForceConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_illuminance_unit_conversion.py b/kittycad/api/unit/get_illuminance_unit_conversion.py new file mode 100644 index 000000000..b21797709 --- /dev/null +++ b/kittycad/api/unit/get_illuminance_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_illuminance_conversion import UnitIlluminanceConversion +from ...models.error import Error +from ...models.unit_illuminance_format import UnitIlluminanceFormat +from ...models.unit_illuminance_format import UnitIlluminanceFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitIlluminanceFormat, + src_format: UnitIlluminanceFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/illuminance/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitIlluminanceConversion, Error]]: + if response.status_code == 200: + response_200 = UnitIlluminanceConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitIlluminanceConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitIlluminanceFormat, + src_format: UnitIlluminanceFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitIlluminanceConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitIlluminanceFormat, + src_format: UnitIlluminanceFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitIlluminanceConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitIlluminanceFormat, + src_format: UnitIlluminanceFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitIlluminanceConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitIlluminanceFormat, + src_format: UnitIlluminanceFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitIlluminanceConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_length_unit_conversion.py b/kittycad/api/unit/get_length_unit_conversion.py new file mode 100644 index 000000000..898a47a38 --- /dev/null +++ b/kittycad/api/unit/get_length_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_length_conversion import UnitLengthConversion +from ...models.error import Error +from ...models.unit_length_format import UnitLengthFormat +from ...models.unit_length_format import UnitLengthFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitLengthFormat, + src_format: UnitLengthFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/length/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitLengthConversion, Error]]: + if response.status_code == 200: + response_200 = UnitLengthConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitLengthConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitLengthFormat, + src_format: UnitLengthFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitLengthConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitLengthFormat, + src_format: UnitLengthFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitLengthConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitLengthFormat, + src_format: UnitLengthFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitLengthConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitLengthFormat, + src_format: UnitLengthFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitLengthConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_magnetic_field_strength_unit_conversion.py b/kittycad/api/unit/get_magnetic_field_strength_unit_conversion.py new file mode 100644 index 000000000..a695e9485 --- /dev/null +++ b/kittycad/api/unit/get_magnetic_field_strength_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_magnetic_field_strength_conversion import UnitMagneticFieldStrengthConversion +from ...models.error import Error +from ...models.unit_magnetic_field_strength_format import UnitMagneticFieldStrengthFormat +from ...models.unit_magnetic_field_strength_format import UnitMagneticFieldStrengthFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitMagneticFieldStrengthFormat, + src_format: UnitMagneticFieldStrengthFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/magnetic-field-strength/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitMagneticFieldStrengthConversion, Error]]: + if response.status_code == 200: + response_200 = UnitMagneticFieldStrengthConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitMagneticFieldStrengthConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitMagneticFieldStrengthFormat, + src_format: UnitMagneticFieldStrengthFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitMagneticFieldStrengthConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitMagneticFieldStrengthFormat, + src_format: UnitMagneticFieldStrengthFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitMagneticFieldStrengthConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitMagneticFieldStrengthFormat, + src_format: UnitMagneticFieldStrengthFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitMagneticFieldStrengthConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitMagneticFieldStrengthFormat, + src_format: UnitMagneticFieldStrengthFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitMagneticFieldStrengthConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_magnetic_flux_unit_conversion.py b/kittycad/api/unit/get_magnetic_flux_unit_conversion.py new file mode 100644 index 000000000..7550f535c --- /dev/null +++ b/kittycad/api/unit/get_magnetic_flux_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_magnetic_flux_conversion import UnitMagneticFluxConversion +from ...models.error import Error +from ...models.unit_magnetic_flux_format import UnitMagneticFluxFormat +from ...models.unit_magnetic_flux_format import UnitMagneticFluxFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitMagneticFluxFormat, + src_format: UnitMagneticFluxFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/magnetic-flux/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitMagneticFluxConversion, Error]]: + if response.status_code == 200: + response_200 = UnitMagneticFluxConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitMagneticFluxConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitMagneticFluxFormat, + src_format: UnitMagneticFluxFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitMagneticFluxConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitMagneticFluxFormat, + src_format: UnitMagneticFluxFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitMagneticFluxConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitMagneticFluxFormat, + src_format: UnitMagneticFluxFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitMagneticFluxConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitMagneticFluxFormat, + src_format: UnitMagneticFluxFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitMagneticFluxConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_mass_unit_conversion.py b/kittycad/api/unit/get_mass_unit_conversion.py new file mode 100644 index 000000000..c232e6a2e --- /dev/null +++ b/kittycad/api/unit/get_mass_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_mass_conversion import UnitMassConversion +from ...models.error import Error +from ...models.unit_mass_format import UnitMassFormat +from ...models.unit_mass_format import UnitMassFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitMassFormat, + src_format: UnitMassFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/mass/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitMassConversion, Error]]: + if response.status_code == 200: + response_200 = UnitMassConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitMassConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitMassFormat, + src_format: UnitMassFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitMassConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitMassFormat, + src_format: UnitMassFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitMassConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitMassFormat, + src_format: UnitMassFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitMassConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitMassFormat, + src_format: UnitMassFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitMassConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/create_unit_conversion.py b/kittycad/api/unit/get_metric_unit_conversion.py similarity index 70% rename from kittycad/api/unit/create_unit_conversion.py rename to kittycad/api/unit/get_metric_unit_conversion.py index 27985dc65..4bba3a29b 100644 --- a/kittycad/api/unit/create_unit_conversion.py +++ b/kittycad/api/unit/get_metric_unit_conversion.py @@ -3,7 +3,7 @@ from typing import Any, Dict, Optional, Union, cast import httpx from ...client import Client -from ...models.unit_conversion import UnitConversion +from ...models.unit_metric_conversion import UnitMetricConversion from ...models.error import Error from ...models.unit_metric_format import UnitMetricFormat from ...models.unit_metric_format import UnitMetricFormat @@ -16,7 +16,7 @@ def _get_kwargs( *, client: Client, ) -> Dict[str, Any]: - url = "{}/unit/conversion/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + url = "{}/unit/conversion/metric/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) headers: Dict[str, Any] = client.get_headers() cookies: Dict[str, Any] = client.get_cookies() @@ -29,10 +29,10 @@ def _get_kwargs( } -def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitConversion, Error]]: - if response.status_code == 201: - response_201 = UnitConversion.from_dict(response.json()) - return response_201 +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitMetricConversion, Error]]: + if response.status_code == 200: + response_200 = UnitMetricConversion.from_dict(response.json()) + return response_200 if response.status_code == 400: response_4XX = Error.from_dict(response.json()) return response_4XX @@ -42,7 +42,7 @@ def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitConv return None -def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitConversion, Error]]: +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitMetricConversion, Error]]: return Response( status_code=response.status_code, content=response.content, @@ -57,7 +57,7 @@ def sync_detailed( value: float, *, client: Client, -) -> Response[Union[Any, UnitConversion, Error]]: +) -> Response[Union[Any, UnitMetricConversion, Error]]: kwargs = _get_kwargs( output_format=output_format, src_format=src_format, @@ -65,7 +65,7 @@ def sync_detailed( client=client, ) - response = httpx.post( + response = httpx.get( verify=client.verify_ssl, **kwargs, ) @@ -79,8 +79,8 @@ def sync( value: float, *, client: Client, -) -> Optional[Union[Any, UnitConversion, Error]]: - """ Convert a metric unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ +) -> Optional[Union[Any, UnitMetricConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ return sync_detailed( output_format=output_format, @@ -96,7 +96,7 @@ async def asyncio_detailed( value: float, *, client: Client, -) -> Response[Union[Any, UnitConversion, Error]]: +) -> Response[Union[Any, UnitMetricConversion, Error]]: kwargs = _get_kwargs( output_format=output_format, src_format=src_format, @@ -105,7 +105,7 @@ async def asyncio_detailed( ) async with httpx.AsyncClient(verify=client.verify_ssl) as _client: - response = await _client.post(**kwargs) + response = await _client.get(**kwargs) return _build_response(response=response) @@ -116,8 +116,8 @@ async def asyncio( value: float, *, client: Client, -) -> Optional[Union[Any, UnitConversion, Error]]: - """ Convert a metric unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ +) -> Optional[Union[Any, UnitMetricConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ return ( await asyncio_detailed( diff --git a/kittycad/api/unit/get_power_unit_conversion.py b/kittycad/api/unit/get_power_unit_conversion.py new file mode 100644 index 000000000..da2d8d718 --- /dev/null +++ b/kittycad/api/unit/get_power_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_power_conversion import UnitPowerConversion +from ...models.error import Error +from ...models.unit_power_format import UnitPowerFormat +from ...models.unit_power_format import UnitPowerFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitPowerFormat, + src_format: UnitPowerFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/power/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitPowerConversion, Error]]: + if response.status_code == 200: + response_200 = UnitPowerConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitPowerConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitPowerFormat, + src_format: UnitPowerFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitPowerConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitPowerFormat, + src_format: UnitPowerFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitPowerConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitPowerFormat, + src_format: UnitPowerFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitPowerConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitPowerFormat, + src_format: UnitPowerFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitPowerConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_pressure_unit_conversion.py b/kittycad/api/unit/get_pressure_unit_conversion.py new file mode 100644 index 000000000..b112fd6cd --- /dev/null +++ b/kittycad/api/unit/get_pressure_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_pressure_conversion import UnitPressureConversion +from ...models.error import Error +from ...models.unit_pressure_format import UnitPressureFormat +from ...models.unit_pressure_format import UnitPressureFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitPressureFormat, + src_format: UnitPressureFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/pressure/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitPressureConversion, Error]]: + if response.status_code == 200: + response_200 = UnitPressureConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitPressureConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitPressureFormat, + src_format: UnitPressureFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitPressureConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitPressureFormat, + src_format: UnitPressureFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitPressureConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitPressureFormat, + src_format: UnitPressureFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitPressureConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitPressureFormat, + src_format: UnitPressureFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitPressureConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_radiation_unit_conversion.py b/kittycad/api/unit/get_radiation_unit_conversion.py new file mode 100644 index 000000000..af9ea63cf --- /dev/null +++ b/kittycad/api/unit/get_radiation_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_radiation_conversion import UnitRadiationConversion +from ...models.error import Error +from ...models.unit_radiation_format import UnitRadiationFormat +from ...models.unit_radiation_format import UnitRadiationFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitRadiationFormat, + src_format: UnitRadiationFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/radiation/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitRadiationConversion, Error]]: + if response.status_code == 200: + response_200 = UnitRadiationConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitRadiationConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitRadiationFormat, + src_format: UnitRadiationFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitRadiationConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitRadiationFormat, + src_format: UnitRadiationFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitRadiationConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitRadiationFormat, + src_format: UnitRadiationFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitRadiationConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitRadiationFormat, + src_format: UnitRadiationFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitRadiationConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_solid_angle_unit_conversion.py b/kittycad/api/unit/get_solid_angle_unit_conversion.py new file mode 100644 index 000000000..2ee3fa032 --- /dev/null +++ b/kittycad/api/unit/get_solid_angle_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_solid_angle_conversion import UnitSolidAngleConversion +from ...models.error import Error +from ...models.unit_solid_angle_format import UnitSolidAngleFormat +from ...models.unit_solid_angle_format import UnitSolidAngleFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitSolidAngleFormat, + src_format: UnitSolidAngleFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/solid-angle/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitSolidAngleConversion, Error]]: + if response.status_code == 200: + response_200 = UnitSolidAngleConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitSolidAngleConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitSolidAngleFormat, + src_format: UnitSolidAngleFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitSolidAngleConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitSolidAngleFormat, + src_format: UnitSolidAngleFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitSolidAngleConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitSolidAngleFormat, + src_format: UnitSolidAngleFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitSolidAngleConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitSolidAngleFormat, + src_format: UnitSolidAngleFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitSolidAngleConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_temperature_unit_conversion.py b/kittycad/api/unit/get_temperature_unit_conversion.py new file mode 100644 index 000000000..2fc61ab09 --- /dev/null +++ b/kittycad/api/unit/get_temperature_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_temperature_conversion import UnitTemperatureConversion +from ...models.error import Error +from ...models.unit_temperature_format import UnitTemperatureFormat +from ...models.unit_temperature_format import UnitTemperatureFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitTemperatureFormat, + src_format: UnitTemperatureFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/temperature/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitTemperatureConversion, Error]]: + if response.status_code == 200: + response_200 = UnitTemperatureConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitTemperatureConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitTemperatureFormat, + src_format: UnitTemperatureFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitTemperatureConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitTemperatureFormat, + src_format: UnitTemperatureFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitTemperatureConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitTemperatureFormat, + src_format: UnitTemperatureFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitTemperatureConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitTemperatureFormat, + src_format: UnitTemperatureFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitTemperatureConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_time_unit_conversion.py b/kittycad/api/unit/get_time_unit_conversion.py new file mode 100644 index 000000000..f4a43d6a9 --- /dev/null +++ b/kittycad/api/unit/get_time_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_time_conversion import UnitTimeConversion +from ...models.error import Error +from ...models.unit_time_format import UnitTimeFormat +from ...models.unit_time_format import UnitTimeFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitTimeFormat, + src_format: UnitTimeFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/time/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitTimeConversion, Error]]: + if response.status_code == 200: + response_200 = UnitTimeConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitTimeConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitTimeFormat, + src_format: UnitTimeFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitTimeConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitTimeFormat, + src_format: UnitTimeFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitTimeConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitTimeFormat, + src_format: UnitTimeFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitTimeConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitTimeFormat, + src_format: UnitTimeFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitTimeConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_velocity_unit_conversion.py b/kittycad/api/unit/get_velocity_unit_conversion.py new file mode 100644 index 000000000..0b980864a --- /dev/null +++ b/kittycad/api/unit/get_velocity_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_velocity_conversion import UnitVelocityConversion +from ...models.error import Error +from ...models.unit_velocity_format import UnitVelocityFormat +from ...models.unit_velocity_format import UnitVelocityFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitVelocityFormat, + src_format: UnitVelocityFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/velocity/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitVelocityConversion, Error]]: + if response.status_code == 200: + response_200 = UnitVelocityConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitVelocityConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitVelocityFormat, + src_format: UnitVelocityFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitVelocityConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitVelocityFormat, + src_format: UnitVelocityFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitVelocityConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitVelocityFormat, + src_format: UnitVelocityFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitVelocityConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitVelocityFormat, + src_format: UnitVelocityFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitVelocityConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_voltage_unit_conversion.py b/kittycad/api/unit/get_voltage_unit_conversion.py new file mode 100644 index 000000000..0ea8d18a6 --- /dev/null +++ b/kittycad/api/unit/get_voltage_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_voltage_conversion import UnitVoltageConversion +from ...models.error import Error +from ...models.unit_voltage_format import UnitVoltageFormat +from ...models.unit_voltage_format import UnitVoltageFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitVoltageFormat, + src_format: UnitVoltageFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/voltage/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitVoltageConversion, Error]]: + if response.status_code == 200: + response_200 = UnitVoltageConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitVoltageConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitVoltageFormat, + src_format: UnitVoltageFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitVoltageConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitVoltageFormat, + src_format: UnitVoltageFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitVoltageConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitVoltageFormat, + src_format: UnitVoltageFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitVoltageConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitVoltageFormat, + src_format: UnitVoltageFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitVoltageConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/api/unit/get_volume_unit_conversion.py b/kittycad/api/unit/get_volume_unit_conversion.py new file mode 100644 index 000000000..fdf3d4a9e --- /dev/null +++ b/kittycad/api/unit/get_volume_unit_conversion.py @@ -0,0 +1,129 @@ +from typing import Any, Dict, Optional, Union, cast + +import httpx + +from ...client import Client +from ...models.unit_volume_conversion import UnitVolumeConversion +from ...models.error import Error +from ...models.unit_volume_format import UnitVolumeFormat +from ...models.unit_volume_format import UnitVolumeFormat +from ...types import Response + +def _get_kwargs( + output_format: UnitVolumeFormat, + src_format: UnitVolumeFormat, + value: float, + *, + client: Client, +) -> Dict[str, Any]: + url = "{}/unit/conversion/volume/{src_format}/{output_format}?value={value}".format(client.base_url, output_format=output_format, src_format=src_format, value=value) + + headers: Dict[str, Any] = client.get_headers() + cookies: Dict[str, Any] = client.get_cookies() + + return { + "url": url, + "headers": headers, + "cookies": cookies, + "timeout": client.get_timeout(), + } + + +def _parse_response(*, response: httpx.Response) -> Optional[Union[Any, UnitVolumeConversion, Error]]: + if response.status_code == 200: + response_200 = UnitVolumeConversion.from_dict(response.json()) + return response_200 + if response.status_code == 400: + response_4XX = Error.from_dict(response.json()) + return response_4XX + if response.status_code == 500: + response_5XX = Error.from_dict(response.json()) + return response_5XX + return None + + +def _build_response(*, response: httpx.Response) -> Response[Union[Any, UnitVolumeConversion, Error]]: + return Response( + status_code=response.status_code, + content=response.content, + headers=response.headers, + parsed=_parse_response(response=response), + ) + + +def sync_detailed( + output_format: UnitVolumeFormat, + src_format: UnitVolumeFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitVolumeConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + response = httpx.get( + verify=client.verify_ssl, + **kwargs, + ) + + return _build_response(response=response) + + +def sync( + output_format: UnitVolumeFormat, + src_format: UnitVolumeFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitVolumeConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return sync_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ).parsed + + +async def asyncio_detailed( + output_format: UnitVolumeFormat, + src_format: UnitVolumeFormat, + value: float, + *, + client: Client, +) -> Response[Union[Any, UnitVolumeConversion, Error]]: + kwargs = _get_kwargs( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + + async with httpx.AsyncClient(verify=client.verify_ssl) as _client: + response = await _client.get(**kwargs) + + return _build_response(response=response) + + +async def asyncio( + output_format: UnitVolumeFormat, + src_format: UnitVolumeFormat, + value: float, + *, + client: Client, +) -> Optional[Union[Any, UnitVolumeConversion, Error]]: + """ Convert a unit value to another metric unit value. This is a nice endpoint to use for helper functions. """ + + return ( + await asyncio_detailed( + output_format=output_format, + src_format=src_format, + value=value, + client=client, + ) + ).parsed diff --git a/kittycad/models/__init__.py b/kittycad/models/__init__.py index 8e1829a8a..127ec3368 100644 --- a/kittycad/models/__init__.py +++ b/kittycad/models/__init__.py @@ -72,8 +72,58 @@ from .system_info_cgroup_driver_enum import SystemInfoCgroupDriverEnum from .system_info_cgroup_version_enum import SystemInfoCgroupVersionEnum from .system_info_default_address_pools import SystemInfoDefaultAddressPools from .system_info_isolation_enum import SystemInfoIsolationEnum -from .unit_conversion import UnitConversion +from .unit_acceleration_conversion import UnitAccelerationConversion +from .unit_acceleration_format import UnitAccelerationFormat +from .unit_angle_conversion import UnitAngleConversion +from .unit_angle_format import UnitAngleFormat +from .unit_angular_velocity_conversion import UnitAngularVelocityConversion +from .unit_angular_velocity_format import UnitAngularVelocityFormat +from .unit_area_conversion import UnitAreaConversion +from .unit_area_format import UnitAreaFormat +from .unit_charge_conversion import UnitChargeConversion +from .unit_charge_format import UnitChargeFormat +from .unit_concentration_conversion import UnitConcentrationConversion +from .unit_concentration_format import UnitConcentrationFormat +from .unit_data_conversion import UnitDataConversion +from .unit_data_format import UnitDataFormat +from .unit_data_transfer_rate_conversion import UnitDataTransferRateConversion +from .unit_data_transfer_rate_format import UnitDataTransferRateFormat +from .unit_density_conversion import UnitDensityConversion +from .unit_density_format import UnitDensityFormat +from .unit_energy_conversion import UnitEnergyConversion +from .unit_energy_format import UnitEnergyFormat +from .unit_force_conversion import UnitForceConversion +from .unit_force_format import UnitForceFormat +from .unit_illuminance_conversion import UnitIlluminanceConversion +from .unit_illuminance_format import UnitIlluminanceFormat +from .unit_length_conversion import UnitLengthConversion +from .unit_length_format import UnitLengthFormat +from .unit_magnetic_field_strength_conversion import UnitMagneticFieldStrengthConversion +from .unit_magnetic_field_strength_format import UnitMagneticFieldStrengthFormat +from .unit_magnetic_flux_conversion import UnitMagneticFluxConversion +from .unit_magnetic_flux_format import UnitMagneticFluxFormat +from .unit_mass_conversion import UnitMassConversion +from .unit_mass_format import UnitMassFormat +from .unit_metric_conversion import UnitMetricConversion from .unit_metric_format import UnitMetricFormat +from .unit_power_conversion import UnitPowerConversion +from .unit_power_format import UnitPowerFormat +from .unit_pressure_conversion import UnitPressureConversion +from .unit_pressure_format import UnitPressureFormat +from .unit_radiation_conversion import UnitRadiationConversion +from .unit_radiation_format import UnitRadiationFormat +from .unit_solid_angle_conversion import UnitSolidAngleConversion +from .unit_solid_angle_format import UnitSolidAngleFormat +from .unit_temperature_conversion import UnitTemperatureConversion +from .unit_temperature_format import UnitTemperatureFormat +from .unit_time_conversion import UnitTimeConversion +from .unit_time_format import UnitTimeFormat +from .unit_velocity_conversion import UnitVelocityConversion +from .unit_velocity_format import UnitVelocityFormat +from .unit_voltage_conversion import UnitVoltageConversion +from .unit_voltage_format import UnitVoltageFormat +from .unit_volume_conversion import UnitVolumeConversion +from .unit_volume_format import UnitVolumeFormat from .update_user import UpdateUser from .user import User from .user_results_page import UserResultsPage diff --git a/kittycad/models/unit_acceleration_conversion.py b/kittycad/models/unit_acceleration_conversion.py new file mode 100644 index 000000000..c7192fe00 --- /dev/null +++ b/kittycad/models/unit_acceleration_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_acceleration_format import UnitAccelerationFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitAccelerationConversion") + + +@attr.s(auto_attribs=True) +class UnitAccelerationConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitAccelerationFormat] = UNSET + src_format: Union[Unset, UnitAccelerationFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitAccelerationFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitAccelerationFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitAccelerationFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitAccelerationFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_acceleration_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_acceleration_conversion.additional_properties = d + return unit_acceleration_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_acceleration_format.py b/kittycad/models/unit_acceleration_format.py new file mode 100644 index 000000000..45306779f --- /dev/null +++ b/kittycad/models/unit_acceleration_format.py @@ -0,0 +1,10 @@ +from enum import Enum + + +class UnitAccelerationFormat(str, Enum): + METERS_PER_SECOND_SQUARED = 'meters_per_second_squared' + FEET_PER_SECOND_SQUARED = 'feet_per_second_squared' + STANDARD_GRAVITY = 'standard_gravity' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_angle_conversion.py b/kittycad/models/unit_angle_conversion.py new file mode 100644 index 000000000..c5aa7644b --- /dev/null +++ b/kittycad/models/unit_angle_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_angle_format import UnitAngleFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitAngleConversion") + + +@attr.s(auto_attribs=True) +class UnitAngleConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitAngleFormat] = UNSET + src_format: Union[Unset, UnitAngleFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitAngleFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitAngleFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitAngleFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitAngleFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_angle_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_angle_conversion.additional_properties = d + return unit_angle_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_angle_format.py b/kittycad/models/unit_angle_format.py new file mode 100644 index 000000000..3fae8ef46 --- /dev/null +++ b/kittycad/models/unit_angle_format.py @@ -0,0 +1,14 @@ +from enum import Enum + + +class UnitAngleFormat(str, Enum): + RADIAN = 'radian' + DEGREE = 'degree' + ARCMINUTE = 'arcminute' + ARCSECOND = 'arcsecond' + MILLIARCSECOND = 'milliarcsecond' + TURN = 'turn' + GRADIAN = 'gradian' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_angular_velocity_conversion.py b/kittycad/models/unit_angular_velocity_conversion.py new file mode 100644 index 000000000..07323492b --- /dev/null +++ b/kittycad/models/unit_angular_velocity_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_angular_velocity_format import UnitAngularVelocityFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitAngularVelocityConversion") + + +@attr.s(auto_attribs=True) +class UnitAngularVelocityConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitAngularVelocityFormat] = UNSET + src_format: Union[Unset, UnitAngularVelocityFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitAngularVelocityFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitAngularVelocityFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitAngularVelocityFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitAngularVelocityFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_angular_velocity_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_angular_velocity_conversion.additional_properties = d + return unit_angular_velocity_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_angular_velocity_format.py b/kittycad/models/unit_angular_velocity_format.py new file mode 100644 index 000000000..d5e9dec92 --- /dev/null +++ b/kittycad/models/unit_angular_velocity_format.py @@ -0,0 +1,11 @@ +from enum import Enum + + +class UnitAngularVelocityFormat(str, Enum): + RADIANS_PER_SECOND = 'radians_per_second' + DEGREES_PER_SECOND = 'degrees_per_second' + REVOLUTIONS_PER_MINUTE = 'revolutions_per_minute' + MILLIARCSECONDS_PER_YEAR = 'milliarcseconds_per_year' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_area_conversion.py b/kittycad/models/unit_area_conversion.py new file mode 100644 index 000000000..02a72b0e9 --- /dev/null +++ b/kittycad/models/unit_area_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_area_format import UnitAreaFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitAreaConversion") + + +@attr.s(auto_attribs=True) +class UnitAreaConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitAreaFormat] = UNSET + src_format: Union[Unset, UnitAreaFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitAreaFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitAreaFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitAreaFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitAreaFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_area_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_area_conversion.additional_properties = d + return unit_area_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_area_format.py b/kittycad/models/unit_area_format.py new file mode 100644 index 000000000..8a5ef1f80 --- /dev/null +++ b/kittycad/models/unit_area_format.py @@ -0,0 +1,14 @@ +from enum import Enum + + +class UnitAreaFormat(str, Enum): + SQUARE_METER = 'square_meter' + SQUARE_FOOT = 'square_foot' + SQUARE_INCH = 'square_inch' + SQUARE_MILE = 'square_mile' + SQUARE_KILOMETER = 'square_kilometer' + HECTARE = 'hectare' + ACRE = 'acre' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_charge_conversion.py b/kittycad/models/unit_charge_conversion.py new file mode 100644 index 000000000..754297a87 --- /dev/null +++ b/kittycad/models/unit_charge_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_charge_format import UnitChargeFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitChargeConversion") + + +@attr.s(auto_attribs=True) +class UnitChargeConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitChargeFormat] = UNSET + src_format: Union[Unset, UnitChargeFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitChargeFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitChargeFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitChargeFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitChargeFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_charge_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_charge_conversion.additional_properties = d + return unit_charge_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_charge_format.py b/kittycad/models/unit_charge_format.py new file mode 100644 index 000000000..ff1cbbf42 --- /dev/null +++ b/kittycad/models/unit_charge_format.py @@ -0,0 +1,9 @@ +from enum import Enum + + +class UnitChargeFormat(str, Enum): + COULOMB = 'coulomb' + AMPERE_HOUR = 'ampere_hour' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_concentration_conversion.py b/kittycad/models/unit_concentration_conversion.py new file mode 100644 index 000000000..1a735eec6 --- /dev/null +++ b/kittycad/models/unit_concentration_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_concentration_format import UnitConcentrationFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitConcentrationConversion") + + +@attr.s(auto_attribs=True) +class UnitConcentrationConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitConcentrationFormat] = UNSET + src_format: Union[Unset, UnitConcentrationFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitConcentrationFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitConcentrationFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitConcentrationFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitConcentrationFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_concentration_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_concentration_conversion.additional_properties = d + return unit_concentration_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_concentration_format.py b/kittycad/models/unit_concentration_format.py new file mode 100644 index 000000000..32c37f611 --- /dev/null +++ b/kittycad/models/unit_concentration_format.py @@ -0,0 +1,11 @@ +from enum import Enum + + +class UnitConcentrationFormat(str, Enum): + PARTS_PER_MILLION = 'parts_per_million' + PARTS_PER_BILLION = 'parts_per_billion' + PARTS_PER_TRILLION = 'parts_per_trillion' + PERCENT = 'percent' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_data_conversion.py b/kittycad/models/unit_data_conversion.py new file mode 100644 index 000000000..17f6b18cf --- /dev/null +++ b/kittycad/models/unit_data_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_data_format import UnitDataFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitDataConversion") + + +@attr.s(auto_attribs=True) +class UnitDataConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitDataFormat] = UNSET + src_format: Union[Unset, UnitDataFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitDataFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitDataFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitDataFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitDataFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_data_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_data_conversion.additional_properties = d + return unit_data_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_data_format.py b/kittycad/models/unit_data_format.py new file mode 100644 index 000000000..f7429d508 --- /dev/null +++ b/kittycad/models/unit_data_format.py @@ -0,0 +1,11 @@ +from enum import Enum + + +class UnitDataFormat(str, Enum): + BYTE = 'byte' + EXABYTE = 'exabyte' + BIT = 'bit' + EXABIT = 'exabit' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_data_transfer_rate_conversion.py b/kittycad/models/unit_data_transfer_rate_conversion.py new file mode 100644 index 000000000..f754bb0c0 --- /dev/null +++ b/kittycad/models/unit_data_transfer_rate_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_data_transfer_rate_format import UnitDataTransferRateFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitDataTransferRateConversion") + + +@attr.s(auto_attribs=True) +class UnitDataTransferRateConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitDataTransferRateFormat] = UNSET + src_format: Union[Unset, UnitDataTransferRateFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitDataTransferRateFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitDataTransferRateFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitDataTransferRateFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitDataTransferRateFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_data_transfer_rate_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_data_transfer_rate_conversion.additional_properties = d + return unit_data_transfer_rate_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_data_transfer_rate_format.py b/kittycad/models/unit_data_transfer_rate_format.py new file mode 100644 index 000000000..a65099f87 --- /dev/null +++ b/kittycad/models/unit_data_transfer_rate_format.py @@ -0,0 +1,11 @@ +from enum import Enum + + +class UnitDataTransferRateFormat(str, Enum): + BYTES_PER_SECOND = 'bytes_per_second' + EXABYTES_PER_SECOND = 'exabytes_per_second' + BITS_PER_SECOND = 'bits_per_second' + EXABITS_PER_SECOND = 'exabits_per_second' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_density_conversion.py b/kittycad/models/unit_density_conversion.py new file mode 100644 index 000000000..d494f92e2 --- /dev/null +++ b/kittycad/models/unit_density_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_density_format import UnitDensityFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitDensityConversion") + + +@attr.s(auto_attribs=True) +class UnitDensityConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitDensityFormat] = UNSET + src_format: Union[Unset, UnitDensityFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitDensityFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitDensityFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitDensityFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitDensityFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_density_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_density_conversion.additional_properties = d + return unit_density_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_density_format.py b/kittycad/models/unit_density_format.py new file mode 100644 index 000000000..fc80a68f9 --- /dev/null +++ b/kittycad/models/unit_density_format.py @@ -0,0 +1,17 @@ +from enum import Enum + + +class UnitDensityFormat(str, Enum): + KILOGRAMS_PER_CUBIC_METER = 'kilograms_per_cubic_meter' + GRAMS_PER_MILLILITER = 'grams_per_milliliter' + KILOGRAMS_PER_LITER = 'kilograms_per_liter' + OUNCES_PER_CUBIC_FOOT = 'ounces_per_cubic_foot' + OUNCES_PER_CUBIC_INCH = 'ounces_per_cubic_inch' + OUNCES_PER_GALLON = 'ounces_per_gallon' + POUNDS_PER_CUBIC_FOOT = 'pounds_per_cubic_foot' + POUNDS_PER_CUBIC_INCH = 'pounds_per_cubic_inch' + POUNDS_PER_GALLON = 'pounds_per_gallon' + SLUGS_PER_CUBIC_FOOT = 'slugs_per_cubic_foot' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_energy_conversion.py b/kittycad/models/unit_energy_conversion.py new file mode 100644 index 000000000..7da18a4af --- /dev/null +++ b/kittycad/models/unit_energy_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_energy_format import UnitEnergyFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitEnergyConversion") + + +@attr.s(auto_attribs=True) +class UnitEnergyConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitEnergyFormat] = UNSET + src_format: Union[Unset, UnitEnergyFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitEnergyFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitEnergyFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitEnergyFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitEnergyFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_energy_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_energy_conversion.additional_properties = d + return unit_energy_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_energy_format.py b/kittycad/models/unit_energy_format.py new file mode 100644 index 000000000..c8aad0616 --- /dev/null +++ b/kittycad/models/unit_energy_format.py @@ -0,0 +1,13 @@ +from enum import Enum + + +class UnitEnergyFormat(str, Enum): + JOULE = 'joule' + CALORIE = 'calorie' + BRITISH_THERMAL_UNIT = 'british_thermal_unit' + BRITISH_THERMAL_UNIT_ISO = 'british_thermal_unit_iso' + BRITISH_THERMAL_UNIT59 = 'british_thermal_unit59' + FOOT_POUND = 'foot_pound' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_force_conversion.py b/kittycad/models/unit_force_conversion.py new file mode 100644 index 000000000..4bf2d6ba4 --- /dev/null +++ b/kittycad/models/unit_force_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_force_format import UnitForceFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitForceConversion") + + +@attr.s(auto_attribs=True) +class UnitForceConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitForceFormat] = UNSET + src_format: Union[Unset, UnitForceFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitForceFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitForceFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitForceFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitForceFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_force_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_force_conversion.additional_properties = d + return unit_force_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_force_format.py b/kittycad/models/unit_force_format.py new file mode 100644 index 000000000..dd38dbbd4 --- /dev/null +++ b/kittycad/models/unit_force_format.py @@ -0,0 +1,12 @@ +from enum import Enum + + +class UnitForceFormat(str, Enum): + NEWTON = 'newton' + POUND = 'pound' + DYNE = 'dyne' + KILOPOUND = 'kilopound' + POUNDAL = 'poundal' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_illuminance_conversion.py b/kittycad/models/unit_illuminance_conversion.py new file mode 100644 index 000000000..67139509e --- /dev/null +++ b/kittycad/models/unit_illuminance_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_illuminance_format import UnitIlluminanceFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitIlluminanceConversion") + + +@attr.s(auto_attribs=True) +class UnitIlluminanceConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitIlluminanceFormat] = UNSET + src_format: Union[Unset, UnitIlluminanceFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitIlluminanceFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitIlluminanceFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitIlluminanceFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitIlluminanceFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_illuminance_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_illuminance_conversion.additional_properties = d + return unit_illuminance_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_illuminance_format.py b/kittycad/models/unit_illuminance_format.py new file mode 100644 index 000000000..271ddabb7 --- /dev/null +++ b/kittycad/models/unit_illuminance_format.py @@ -0,0 +1,11 @@ +from enum import Enum + + +class UnitIlluminanceFormat(str, Enum): + LUX = 'lux' + FOOTCANDLE = 'footcandle' + LUMENS_PER_SQUARE_INCH = 'lumens_per_square_inch' + PHOT = 'phot' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_length_conversion.py b/kittycad/models/unit_length_conversion.py new file mode 100644 index 000000000..65b000454 --- /dev/null +++ b/kittycad/models/unit_length_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_length_format import UnitLengthFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitLengthConversion") + + +@attr.s(auto_attribs=True) +class UnitLengthConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitLengthFormat] = UNSET + src_format: Union[Unset, UnitLengthFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitLengthFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitLengthFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitLengthFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitLengthFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_length_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_length_conversion.additional_properties = d + return unit_length_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_length_format.py b/kittycad/models/unit_length_format.py new file mode 100644 index 000000000..e6cfc2ffd --- /dev/null +++ b/kittycad/models/unit_length_format.py @@ -0,0 +1,21 @@ +from enum import Enum + + +class UnitLengthFormat(str, Enum): + METER = 'meter' + FOOT = 'foot' + INCH = 'inch' + MILE = 'mile' + NAUTICAL_MILE = 'nautical_mile' + ASTRONOMICAL_UNIT = 'astronomical_unit' + CUBIT = 'cubit' + FATHOM = 'fathom' + CHAIN = 'chain' + FURLONG = 'furlong' + HAND = 'hand' + LEAGUE = 'league' + NAUTICAL_LEAGUE = 'nautical_league' + YARD = 'yard' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_magnetic_field_strength_conversion.py b/kittycad/models/unit_magnetic_field_strength_conversion.py new file mode 100644 index 000000000..6e8e653df --- /dev/null +++ b/kittycad/models/unit_magnetic_field_strength_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_magnetic_field_strength_format import UnitMagneticFieldStrengthFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitMagneticFieldStrengthConversion") + + +@attr.s(auto_attribs=True) +class UnitMagneticFieldStrengthConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitMagneticFieldStrengthFormat] = UNSET + src_format: Union[Unset, UnitMagneticFieldStrengthFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitMagneticFieldStrengthFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitMagneticFieldStrengthFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitMagneticFieldStrengthFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitMagneticFieldStrengthFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_magnetic_field_strength_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_magnetic_field_strength_conversion.additional_properties = d + return unit_magnetic_field_strength_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_magnetic_field_strength_format.py b/kittycad/models/unit_magnetic_field_strength_format.py new file mode 100644 index 000000000..c0c7240b1 --- /dev/null +++ b/kittycad/models/unit_magnetic_field_strength_format.py @@ -0,0 +1,9 @@ +from enum import Enum + + +class UnitMagneticFieldStrengthFormat(str, Enum): + TESLA = 'tesla' + GAUSS = 'gauss' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_magnetic_flux_conversion.py b/kittycad/models/unit_magnetic_flux_conversion.py new file mode 100644 index 000000000..7bd4550ca --- /dev/null +++ b/kittycad/models/unit_magnetic_flux_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_magnetic_flux_format import UnitMagneticFluxFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitMagneticFluxConversion") + + +@attr.s(auto_attribs=True) +class UnitMagneticFluxConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitMagneticFluxFormat] = UNSET + src_format: Union[Unset, UnitMagneticFluxFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitMagneticFluxFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitMagneticFluxFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitMagneticFluxFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitMagneticFluxFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_magnetic_flux_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_magnetic_flux_conversion.additional_properties = d + return unit_magnetic_flux_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_magnetic_flux_format.py b/kittycad/models/unit_magnetic_flux_format.py new file mode 100644 index 000000000..50a15fb0f --- /dev/null +++ b/kittycad/models/unit_magnetic_flux_format.py @@ -0,0 +1,9 @@ +from enum import Enum + + +class UnitMagneticFluxFormat(str, Enum): + WEBER = 'weber' + MAXWELL = 'maxwell' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_mass_conversion.py b/kittycad/models/unit_mass_conversion.py new file mode 100644 index 000000000..d5aa28d4c --- /dev/null +++ b/kittycad/models/unit_mass_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_mass_format import UnitMassFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitMassConversion") + + +@attr.s(auto_attribs=True) +class UnitMassConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitMassFormat] = UNSET + src_format: Union[Unset, UnitMassFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitMassFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitMassFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitMassFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitMassFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_mass_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_mass_conversion.additional_properties = d + return unit_mass_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_mass_format.py b/kittycad/models/unit_mass_format.py new file mode 100644 index 000000000..f4196f88c --- /dev/null +++ b/kittycad/models/unit_mass_format.py @@ -0,0 +1,16 @@ +from enum import Enum + + +class UnitMassFormat(str, Enum): + GRAM = 'gram' + METRIC_TON = 'metric_ton' + POUND = 'pound' + LONG_TON = 'long_ton' + SHORT_TON = 'short_ton' + STONE = 'stone' + OUNCE = 'ounce' + CARAT = 'carat' + SLUG = 'slug' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_conversion.py b/kittycad/models/unit_metric_conversion.py similarity index 96% rename from kittycad/models/unit_conversion.py rename to kittycad/models/unit_metric_conversion.py index 9de6b32a8..2dd4b6671 100644 --- a/kittycad/models/unit_conversion.py +++ b/kittycad/models/unit_metric_conversion.py @@ -9,11 +9,11 @@ from ..models.unit_metric_format import UnitMetricFormat from ..models.api_call_status import ApiCallStatus from ..types import UNSET, Unset -T = TypeVar("T", bound="UnitConversion") +T = TypeVar("T", bound="UnitMetricConversion") @attr.s(auto_attribs=True) -class UnitConversion: +class UnitMetricConversion: """ """ completed_at: Union[Unset, datetime.datetime] = UNSET created_at: Union[Unset, datetime.datetime] = UNSET @@ -150,7 +150,7 @@ class UnitConversion: user_id = d.pop("user_id", UNSET) - unit_conversion = cls( + unit_metric_conversion = cls( completed_at=completed_at, created_at=created_at, error=error, @@ -165,8 +165,8 @@ class UnitConversion: user_id=user_id, ) - unit_conversion.additional_properties = d - return unit_conversion + unit_metric_conversion.additional_properties = d + return unit_metric_conversion @property def additional_keys(self) -> List[str]: diff --git a/kittycad/models/unit_power_conversion.py b/kittycad/models/unit_power_conversion.py new file mode 100644 index 000000000..33902fa91 --- /dev/null +++ b/kittycad/models/unit_power_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_power_format import UnitPowerFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitPowerConversion") + + +@attr.s(auto_attribs=True) +class UnitPowerConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitPowerFormat] = UNSET + src_format: Union[Unset, UnitPowerFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitPowerFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitPowerFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitPowerFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitPowerFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_power_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_power_conversion.additional_properties = d + return unit_power_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_power_format.py b/kittycad/models/unit_power_format.py new file mode 100644 index 000000000..75b8e7679 --- /dev/null +++ b/kittycad/models/unit_power_format.py @@ -0,0 +1,10 @@ +from enum import Enum + + +class UnitPowerFormat(str, Enum): + WATT = 'watt' + HORSEPOWER = 'horsepower' + MILLIWATT = 'milliwatt' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_pressure_conversion.py b/kittycad/models/unit_pressure_conversion.py new file mode 100644 index 000000000..431e0b141 --- /dev/null +++ b/kittycad/models/unit_pressure_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_pressure_format import UnitPressureFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitPressureConversion") + + +@attr.s(auto_attribs=True) +class UnitPressureConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitPressureFormat] = UNSET + src_format: Union[Unset, UnitPressureFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitPressureFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitPressureFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitPressureFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitPressureFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_pressure_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_pressure_conversion.additional_properties = d + return unit_pressure_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_pressure_format.py b/kittycad/models/unit_pressure_format.py new file mode 100644 index 000000000..f0fe41000 --- /dev/null +++ b/kittycad/models/unit_pressure_format.py @@ -0,0 +1,12 @@ +from enum import Enum + + +class UnitPressureFormat(str, Enum): + PASCAL = 'pascal' + BAR = 'bar' + MBAR = 'mbar' + ATMOSPHERE = 'atmosphere' + POUNDS_PER_SQUARE_INCH = 'pounds_per_square_inch' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_radiation_conversion.py b/kittycad/models/unit_radiation_conversion.py new file mode 100644 index 000000000..7ed1a1179 --- /dev/null +++ b/kittycad/models/unit_radiation_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_radiation_format import UnitRadiationFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitRadiationConversion") + + +@attr.s(auto_attribs=True) +class UnitRadiationConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitRadiationFormat] = UNSET + src_format: Union[Unset, UnitRadiationFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitRadiationFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitRadiationFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitRadiationFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitRadiationFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_radiation_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_radiation_conversion.additional_properties = d + return unit_radiation_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_radiation_format.py b/kittycad/models/unit_radiation_format.py new file mode 100644 index 000000000..f12157c1e --- /dev/null +++ b/kittycad/models/unit_radiation_format.py @@ -0,0 +1,10 @@ +from enum import Enum + + +class UnitRadiationFormat(str, Enum): + GRAY = 'gray' + SIEVERT = 'sievert' + RAD = 'rad' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_solid_angle_conversion.py b/kittycad/models/unit_solid_angle_conversion.py new file mode 100644 index 000000000..9230bd664 --- /dev/null +++ b/kittycad/models/unit_solid_angle_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_solid_angle_format import UnitSolidAngleFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitSolidAngleConversion") + + +@attr.s(auto_attribs=True) +class UnitSolidAngleConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitSolidAngleFormat] = UNSET + src_format: Union[Unset, UnitSolidAngleFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitSolidAngleFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitSolidAngleFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitSolidAngleFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitSolidAngleFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_solid_angle_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_solid_angle_conversion.additional_properties = d + return unit_solid_angle_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_solid_angle_format.py b/kittycad/models/unit_solid_angle_format.py new file mode 100644 index 000000000..bf6a4acb7 --- /dev/null +++ b/kittycad/models/unit_solid_angle_format.py @@ -0,0 +1,10 @@ +from enum import Enum + + +class UnitSolidAngleFormat(str, Enum): + STERADIAN = 'steradian' + DEGREE_SQUARED = 'degree_squared' + SPAT = 'spat' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_temperature_conversion.py b/kittycad/models/unit_temperature_conversion.py new file mode 100644 index 000000000..dc557bf76 --- /dev/null +++ b/kittycad/models/unit_temperature_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_temperature_format import UnitTemperatureFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitTemperatureConversion") + + +@attr.s(auto_attribs=True) +class UnitTemperatureConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitTemperatureFormat] = UNSET + src_format: Union[Unset, UnitTemperatureFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitTemperatureFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitTemperatureFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitTemperatureFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitTemperatureFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_temperature_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_temperature_conversion.additional_properties = d + return unit_temperature_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_temperature_format.py b/kittycad/models/unit_temperature_format.py new file mode 100644 index 000000000..fda1fa957 --- /dev/null +++ b/kittycad/models/unit_temperature_format.py @@ -0,0 +1,12 @@ +from enum import Enum + + +class UnitTemperatureFormat(str, Enum): + KELVIN = 'kelvin' + CELSIUS = 'celsius' + FAHRENHEIT = 'fahrenheit' + REAUMUR = 'reaumur' + RANKINE = 'rankine' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_time_conversion.py b/kittycad/models/unit_time_conversion.py new file mode 100644 index 000000000..afdd8e0e8 --- /dev/null +++ b/kittycad/models/unit_time_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_time_format import UnitTimeFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitTimeConversion") + + +@attr.s(auto_attribs=True) +class UnitTimeConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitTimeFormat] = UNSET + src_format: Union[Unset, UnitTimeFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitTimeFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitTimeFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitTimeFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitTimeFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_time_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_time_conversion.additional_properties = d + return unit_time_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_time_format.py b/kittycad/models/unit_time_format.py new file mode 100644 index 000000000..bf915ed42 --- /dev/null +++ b/kittycad/models/unit_time_format.py @@ -0,0 +1,15 @@ +from enum import Enum + + +class UnitTimeFormat(str, Enum): + SECOND = 'second' + MINUTE = 'minute' + HOUR = 'hour' + DAY = 'day' + WEEK = 'week' + YEAR = 'year' + JULIAN_YEAR = 'julian_year' + GREGORIAN_YEAR = 'gregorian_year' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_velocity_conversion.py b/kittycad/models/unit_velocity_conversion.py new file mode 100644 index 000000000..2a692a8ea --- /dev/null +++ b/kittycad/models/unit_velocity_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_velocity_format import UnitVelocityFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitVelocityConversion") + + +@attr.s(auto_attribs=True) +class UnitVelocityConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitVelocityFormat] = UNSET + src_format: Union[Unset, UnitVelocityFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitVelocityFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitVelocityFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitVelocityFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitVelocityFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_velocity_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_velocity_conversion.additional_properties = d + return unit_velocity_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_velocity_format.py b/kittycad/models/unit_velocity_format.py new file mode 100644 index 000000000..7998a4434 --- /dev/null +++ b/kittycad/models/unit_velocity_format.py @@ -0,0 +1,12 @@ +from enum import Enum + + +class UnitVelocityFormat(str, Enum): + METERS_PER_SECOND = 'meters_per_second' + FEET_PER_SECOND = 'feet_per_second' + MILES_PER_HOUR = 'miles_per_hour' + KILOMETERS_PER_HOUR = 'kilometers_per_hour' + KNOT = 'knot' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_voltage_conversion.py b/kittycad/models/unit_voltage_conversion.py new file mode 100644 index 000000000..47fb1b082 --- /dev/null +++ b/kittycad/models/unit_voltage_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_voltage_format import UnitVoltageFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitVoltageConversion") + + +@attr.s(auto_attribs=True) +class UnitVoltageConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitVoltageFormat] = UNSET + src_format: Union[Unset, UnitVoltageFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitVoltageFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitVoltageFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitVoltageFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitVoltageFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_voltage_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_voltage_conversion.additional_properties = d + return unit_voltage_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_voltage_format.py b/kittycad/models/unit_voltage_format.py new file mode 100644 index 000000000..89bc4284c --- /dev/null +++ b/kittycad/models/unit_voltage_format.py @@ -0,0 +1,10 @@ +from enum import Enum + + +class UnitVoltageFormat(str, Enum): + VOLT = 'volt' + STATVOLT = 'statvolt' + ABVOLT = 'abvolt' + + def __str__(self) -> str: + return str(self.value) diff --git a/kittycad/models/unit_volume_conversion.py b/kittycad/models/unit_volume_conversion.py new file mode 100644 index 000000000..2032c0ad6 --- /dev/null +++ b/kittycad/models/unit_volume_conversion.py @@ -0,0 +1,185 @@ +import datetime +from typing import Any, Dict, List, Type, TypeVar, Union, cast + +import attr +from dateutil.parser import isoparse + +from ..models.uuid import Uuid +from ..models.unit_volume_format import UnitVolumeFormat +from ..models.api_call_status import ApiCallStatus +from ..types import UNSET, Unset + +T = TypeVar("T", bound="UnitVolumeConversion") + + +@attr.s(auto_attribs=True) +class UnitVolumeConversion: + """ """ + completed_at: Union[Unset, datetime.datetime] = UNSET + created_at: Union[Unset, datetime.datetime] = UNSET + error: Union[Unset, str] = UNSET + id: Union[Unset, str] = UNSET + input: Union[Unset, float] = UNSET + output: Union[Unset, float] = UNSET + output_format: Union[Unset, UnitVolumeFormat] = UNSET + src_format: Union[Unset, UnitVolumeFormat] = UNSET + started_at: Union[Unset, datetime.datetime] = UNSET + status: Union[Unset, ApiCallStatus] = UNSET + updated_at: Union[Unset, datetime.datetime] = UNSET + user_id: Union[Unset, str] = UNSET + + additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict) + + def to_dict(self) -> Dict[str, Any]: + completed_at: Union[Unset, str] = UNSET + if not isinstance(self.completed_at, Unset): + completed_at = self.completed_at.isoformat() + created_at: Union[Unset, str] = UNSET + if not isinstance(self.created_at, Unset): + created_at = self.created_at.isoformat() + error = self.error + id = self.id + input = self.input + output = self.output + output_format: Union[Unset, str] = UNSET + if not isinstance(self.output_format, Unset): + output_format = self.output_format.value + src_format: Union[Unset, str] = UNSET + if not isinstance(self.src_format, Unset): + src_format = self.src_format.value + started_at: Union[Unset, str] = UNSET + if not isinstance(self.started_at, Unset): + started_at = self.started_at.isoformat() + status: Union[Unset, str] = UNSET + if not isinstance(self.status, Unset): + status = self.status.value + updated_at: Union[Unset, str] = UNSET + if not isinstance(self.updated_at, Unset): + updated_at = self.updated_at.isoformat() + user_id = self.user_id + + field_dict: Dict[str, Any] = {} + field_dict.update(self.additional_properties) + field_dict.update({}) + if completed_at is not UNSET: + field_dict['completed_at'] = completed_at + if created_at is not UNSET: + field_dict['created_at'] = created_at + if error is not UNSET: + field_dict['error'] = error + if id is not UNSET: + field_dict['id'] = id + if input is not UNSET: + field_dict['input'] = input + if output is not UNSET: + field_dict['output'] = output + if output_format is not UNSET: + field_dict['output_format'] = output_format + if src_format is not UNSET: + field_dict['src_format'] = src_format + if started_at is not UNSET: + field_dict['started_at'] = started_at + if status is not UNSET: + field_dict['status'] = status + if updated_at is not UNSET: + field_dict['updated_at'] = updated_at + if user_id is not UNSET: + field_dict['user_id'] = user_id + + return field_dict + + @classmethod + def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T: + d = src_dict.copy() + _completed_at = d.pop("completed_at", UNSET) + completed_at: Union[Unset, datetime.datetime] + if isinstance(_completed_at, Unset): + completed_at = UNSET + else: + completed_at = isoparse(_completed_at) + + _created_at = d.pop("created_at", UNSET) + created_at: Union[Unset, datetime.datetime] + if isinstance(_created_at, Unset): + created_at = UNSET + else: + created_at = isoparse(_created_at) + + error = d.pop("error", UNSET) + + id = d.pop("id", UNSET) + + input = d.pop("input", UNSET) + + output = d.pop("output", UNSET) + + _output_format = d.pop("output_format", UNSET) + output_format: Union[Unset, UnitVolumeFormat] + if isinstance(_output_format, Unset): + output_format = UNSET + else: + output_format = UnitVolumeFormat(_output_format) + + _src_format = d.pop("src_format", UNSET) + src_format: Union[Unset, UnitVolumeFormat] + if isinstance(_src_format, Unset): + src_format = UNSET + else: + src_format = UnitVolumeFormat(_src_format) + + _started_at = d.pop("started_at", UNSET) + started_at: Union[Unset, datetime.datetime] + if isinstance(_started_at, Unset): + started_at = UNSET + else: + started_at = isoparse(_started_at) + + _status = d.pop("status", UNSET) + status: Union[Unset, ApiCallStatus] + if isinstance(_status, Unset): + status = UNSET + else: + status = ApiCallStatus(_status) + + _updated_at = d.pop("updated_at", UNSET) + updated_at: Union[Unset, datetime.datetime] + if isinstance(_updated_at, Unset): + updated_at = UNSET + else: + updated_at = isoparse(_updated_at) + + user_id = d.pop("user_id", UNSET) + + unit_volume_conversion = cls( + completed_at=completed_at, + created_at=created_at, + error=error, + id=id, + input=input, + output=output, + output_format=output_format, + src_format=src_format, + started_at=started_at, + status=status, + updated_at=updated_at, + user_id=user_id, + ) + + unit_volume_conversion.additional_properties = d + return unit_volume_conversion + + @property + def additional_keys(self) -> List[str]: + return list(self.additional_properties.keys()) + + def __getitem__(self, key: str) -> Any: + return self.additional_properties[key] + + def __setitem__(self, key: str, value: Any) -> None: + self.additional_properties[key] = value + + def __delitem__(self, key: str) -> None: + del self.additional_properties[key] + + def __contains__(self, key: str) -> bool: + return key in self.additional_properties diff --git a/kittycad/models/unit_volume_format.py b/kittycad/models/unit_volume_format.py new file mode 100644 index 000000000..3c025107e --- /dev/null +++ b/kittycad/models/unit_volume_format.py @@ -0,0 +1,14 @@ +from enum import Enum + + +class UnitVolumeFormat(str, Enum): + CUBIC_METER = 'cubic_meter' + CUBIC_MILLIMETER = 'cubic_millimeter' + CUBIC_KILOMETER = 'cubic_kilometer' + LITER = 'liter' + CUBIC_FOOT = 'cubic_foot' + CUBIC_YARD = 'cubic_yard' + CUBIC_MILE = 'cubic_mile' + + def __str__(self) -> str: + return str(self.value)