diff --git a/model/equaliq.smithy b/model/equaliq.smithy index f7dd91d..0e3716c 100644 --- a/model/equaliq.smithy +++ b/model/equaliq.smithy @@ -27,10 +27,35 @@ service EqualIQ { GetContractSignatures UpdateSignatureStatus DeleteContractSignature + CreateComposerContract + GetComposerContractMeta + GetComposerContractContent + UpdateComposerContractMeta + UpdateComposerContractContent + SaveComposerContractToVault + ListComposerContracts + ListComposerContractVersions + ArchiveComposerContract ] } +resource ComposerContract { + identifiers: { contractId: ComposerContractId } + create: CreateComposerContract + read: GetComposerContractMeta + update: UpdateComposerContractMeta + delete: ArchiveComposerContract + list: ListComposerContracts + + operations: [ + GetComposerContractContent, + UpdateComposerContractContent, + SaveComposerContractToVault, + ListComposerContractVersions + ] +} + // When changing APIs, we sometimes want to expose unified types that aren't directly tied to any API. structure ExposedTypes { QASectionsList: QASectionsList @@ -49,6 +74,12 @@ string ContractId @pattern("^[A-Za-z0-9-]+$") string UserId +@pattern("^[A-Fa-f0-9-]{36}$") +string ComposerContractId + +@pattern("^[A-Fa-f0-9-]{36}$") +string RevisionId + list UserIdList { member: UserId } @@ -98,6 +129,25 @@ enum SignContractResult { FAILURE } +enum ComposerContractStatus { + NEW + CLEAN_IN_VAULT + DIRTY + ARCHIVED +} + +enum ComposerContractType { + PRODUCER +} + +enum ComposerContractSection { + SERVICES + COMPENSATION + INTELLECTUAL_PROPERTY + TERM_AND_TERMINATION + CONFIDENTIALITY +} + // Contract operations @http(method: "POST", uri: "/getContract") operation GetContract { @@ -217,6 +267,7 @@ structure ContractSummaryItem { sharedWith: UserIdList sharedUsers: UserIdList sharedEmails: EmailList + isComposerGenerated: Boolean } @idempotent @@ -698,3 +749,205 @@ structure DeleteContractSignatureOutput { message: String } +structure ComposerContractMeta { + contractId: ComposerContractId + revisionId: String + title: String + type: ComposerContractType + status: ComposerContractStatus + createdAt: Timestamp + updatedAt: Timestamp + revisionHistory: RevisionIdList +} + +list RevisionIdList { + member: String +} + +structure ComposerContractContent { + sections: ComposerContractSectionList +} + +structure ComposerContractData { + meta: ComposerContractMeta + content: ComposerContractContent +} + +list ComposerContractSectionList { + member: SectionUnion +} + +union SectionUnion { + term: TermSection + clause: ClauseSection + // more structured section types +} + +structure TermSection { + sectionId: ComposerContractSection + name: String + definition: String + citation: String + unit: String +} + +structure ClauseSection { + sectionId: ComposerContractSection + text: String +} + + +@idempotent +@http(method: "POST", uri: "/composer/create") +operation CreateComposerContract { + input: CreateComposerContractInput + output: CreateComposerContractOutput +} + +structure CreateComposerContractInput { + @required + title: String + @required + type: ComposerContractType + formDetails: ComposerFormData + sourceRevisionId: RevisionId +} +structure CreateComposerContractOutput { + contract: ComposerContractData +} + +structure ComposerFormData { + clientName: String + providerName: String + date: String +} + +@readonly +@http(method: "POST", uri: "/composer/getMeta") +operation GetComposerContractMeta { + input: GetComposerContractInput + output: GetComposerContractMetaOutput +} + +structure GetComposerContractMetaOutput { + meta: ComposerContractMeta +} + +@http(method: "POST", uri: "/composer/getContent") +operation GetComposerContractContent { + input: GetComposerContractInput + output: GetComposerContractContentOutput +} +structure GetComposerContractInput { + @required + contractId: ComposerContractId +} + +structure GetComposerContractContentOutput { + content: ComposerContractContent +} + + +@idempotent +@http(method: "POST", uri: "/composer/updateMeta") +operation UpdateComposerContractMeta { + input: UpdateComposerContractMetaInput + output: UpdateComposerContractMetaOutput +} + +structure UpdateComposerContractMetaInput { + @required + contractId: ComposerContractId + title: String + sections: ComposerContractSectionList + status: ComposerContractStatus +} + +structure UpdateComposerContractMetaOutput { + contract: ComposerContractData +} + +@http(method: "POST", uri: "/composer/updateContent") +operation UpdateComposerContractContent { + input: UpdateComposerContractContentInput + output: UpdateComposerContractContentOutput +} + +structure UpdateComposerContractContentInput { + @required + contractId: ComposerContractId + sections: ComposerContractSectionList +} + +structure UpdateComposerContractContentOutput { + contract: ComposerContractData +} + +@readonly +@http(method: "POST", uri: "/composer/list") +operation ListComposerContracts { + input: ListComposerContractsInput + output: ListComposerContractsOutput +} + +structure ListComposerContractsInput { + // temp - ask Parker +} + +list ComposerContractMetaList { + member: ComposerContractMeta +} + +structure ListComposerContractsOutput { + contracts: ComposerContractMetaList +} + +@http(method: "POST", uri: "/composer/listVersions") +operation ListComposerContractVersions { + input: GetComposerContractInput + output: ListComposerContractVersionsOutput +} + +structure ListComposerContractVersionsOutput { + contractId: ComposerContractId + versions: ComposerContractMetaList +} + +@http(method: "POST", uri: "/composer/publish") +operation SaveComposerContractToVault { + input: SaveComposerContractToVaultInput + output: SaveComposerContractToVaultOutput +} + +structure SaveComposerContractToVaultInput { + @required + contractId: ComposerContractId +} + +structure SaveComposerContractToVaultOutput { + @required + message: String +} + +@idempotent +@http(method: "POST", uri: "/composer/archive") +operation ArchiveComposerContract { + input: ArchiveComposerContractInput + output: ArchiveComposerContractOutput + errors: [ + AuthenticationError, + ResourceNotFoundError, + InternalServerError + ] +} + +structure ArchiveComposerContractInput { + @required + contractId: ComposerContractId +} + +structure ArchiveComposerContractOutput { + @required + message: String +} + diff --git a/python/api_model/types/models.py b/python/api_model/types/models.py index 6c9feed..dce1d0c 100644 --- a/python/api_model/types/models.py +++ b/python/api_model/types/models.py @@ -1,11 +1,11 @@ # generated by datamodel-codegen: # filename: api.json -# timestamp: 2025-05-26T18:04:34+00:00 +# timestamp: 2025-05-30T21:03:47+00:00 from __future__ import annotations from enum import Enum -from typing import Any, List, Optional +from typing import Any, List, Optional, Union from pydantic import BaseModel, Field, RootModel @@ -18,10 +18,43 @@ class AccountType(Enum): publisher = 'publisher' +class ArchiveComposerContractRequestContent(BaseModel): + contractId: str = Field(..., pattern='^[A-Fa-f0-9-]{36}$') + + +class ArchiveComposerContractResponseContent(BaseModel): + message: str + + class AuthenticationErrorResponseContent(BaseModel): message: str +class ComposerContractSection(Enum): + SERVICES = 'SERVICES' + COMPENSATION = 'COMPENSATION' + INTELLECTUAL_PROPERTY = 'INTELLECTUAL_PROPERTY' + TERM_AND_TERMINATION = 'TERM_AND_TERMINATION' + CONFIDENTIALITY = 'CONFIDENTIALITY' + + +class ComposerContractStatus(Enum): + NEW = 'NEW' + CLEAN_IN_VAULT = 'CLEAN_IN_VAULT' + DIRTY = 'DIRTY' + ARCHIVED = 'ARCHIVED' + + +class ComposerContractType(Enum): + PRODUCER = 'PRODUCER' + + +class ComposerFormData(BaseModel): + clientName: Optional[str] = None + providerName: Optional[str] = None + date: Optional[str] = None + + class ContractStatus(Enum): processing = 'processing' complete = 'complete' @@ -45,6 +78,13 @@ class ContractType(Enum): tbd = 'tbd' +class CreateComposerContractRequestContent(BaseModel): + title: str + type: ComposerContractType + formDetails: Optional[ComposerFormData] = None + sourceRevisionId: Optional[str] = Field(None, pattern='^[A-Fa-f0-9-]{36}$') + + class DeleteContractRequestContent(BaseModel): contractId: str = Field(..., pattern='^[A-Za-z0-9-]+$') @@ -53,6 +93,10 @@ class DeleteContractResponseContent(BaseModel): success: bool +class DeleteContractSignatureRequestContent(BaseModel): + contractId: str + + class FixedTermValue(BaseModel): unit: str value: str @@ -66,8 +110,12 @@ class FixedValueTermInference(BaseModel): subterms: Optional[List[FixedTermValue]] = None -class DeleteContractSignatureRequestContent(BaseModel): - contractId: str +class GetComposerContractContentRequestContent(BaseModel): + contractId: str = Field(..., pattern='^[A-Fa-f0-9-]{36}$') + + +class GetComposerContractMetaRequestContent(BaseModel): + contractId: str = Field(..., pattern='^[A-Fa-f0-9-]{36}$') class GetContractReadURLRequestContent(BaseModel): @@ -106,6 +154,10 @@ class InternalServerErrorResponseContent(BaseModel): message: str +class ListComposerContractVersionsRequestContent(BaseModel): + contractId: str = Field(..., pattern='^[A-Fa-f0-9-]{36}$') + + class PingResponseContent(BaseModel): message: str @@ -133,6 +185,14 @@ class ResourceNotFoundErrorResponseContent(BaseModel): message: str +class SaveComposerContractToVaultRequestContent(BaseModel): + contractId: str = Field(..., pattern='^[A-Fa-f0-9-]{36}$') + + +class SaveComposerContractToVaultResponseContent(BaseModel): + message: str + + class ShareContractRequestContent(BaseModel): contractId: str = Field(..., pattern='^[A-Za-z0-9-]+$') emailsToAdd: Optional[List[str]] = None @@ -145,14 +205,6 @@ class SharedUserDetails(BaseModel): sharedTime: float -class Term(BaseModel): - name: str - definition: str - unitType: str - citation: Optional[str] = None - fixedValues: Optional[FixedValueTermInference] = None - - class SignContractResult(Enum): SUCCESS = 'SUCCESS' FAILURE = 'FAILURE' @@ -164,6 +216,22 @@ class SignatureStatus(Enum): pending = 'pending' +class Term(BaseModel): + name: str + definition: str + unitType: str + citation: Optional[str] = None + fixedValues: Optional[FixedValueTermInference] = None + + +class TermSection(BaseModel): + sectionId: Optional[ComposerContractSection] = None + name: Optional[str] = None + definition: Optional[str] = None + citation: Optional[str] = None + unit: Optional[str] = None + + class UpdateContractRequestContent(BaseModel): contractId: str = Field(..., pattern='^[A-Za-z0-9-]+$') name: str @@ -223,6 +291,22 @@ class ValidationErrorResponseContent(BaseModel): message: str +class ClauseSection(BaseModel): + sectionId: Optional[ComposerContractSection] = None + text: Optional[str] = None + + +class ComposerContractMeta(BaseModel): + contractId: Optional[str] = Field(None, pattern='^[A-Fa-f0-9-]{36}$') + revisionId: Optional[str] = None + title: Optional[str] = None + type: Optional[ComposerContractType] = None + status: Optional[ComposerContractStatus] = None + createdAt: Optional[float] = None + updatedAt: Optional[float] = None + revisionHistory: Optional[List[str]] = None + + class ContractSignature(BaseModel): userId: Optional[str] = None status: Optional[SignatureStatus] = None @@ -240,12 +324,22 @@ class ContractSummaryItem(BaseModel): sharedWith: Optional[List[SharedWithItem]] = None sharedUsers: Optional[List[SharedUser]] = None sharedEmails: Optional[List[str]] = None + isComposerGenerated: Optional[bool] = None + + +class DeleteContractSignatureResponseContent(BaseModel): + result: Optional[SignContractResult] = None + message: Optional[str] = None class ExposeTypesResponseContent(BaseModel): QASectionsList: Optional[List[QASection]] = None +class GetComposerContractMetaResponseContent(BaseModel): + meta: Optional[ComposerContractMeta] = None + + class GetContractResponseContent(BaseModel): contractId: str = Field(..., pattern='^[A-Za-z0-9-]+$') name: str @@ -257,11 +351,6 @@ class GetContractResponseContent(BaseModel): sharedWith: List[SharedWithItem] -class DeleteContractSignatureResponseContent(BaseModel): - result: Optional[SignContractResult] = None - message: Optional[str] = None - - class GetContractSignaturesResponseContent(BaseModel): contractId: Optional[str] = None signatures: Optional[List[ContractSignature]] = None @@ -276,11 +365,32 @@ class GetUploadURLResponseContent(BaseModel): url_info: PresignedPostData +class ListComposerContractVersionsResponseContent(BaseModel): + contractId: Optional[str] = Field(None, pattern='^[A-Fa-f0-9-]{36}$') + versions: Optional[List[ComposerContractMeta]] = None + + +class ListComposerContractsResponseContent(BaseModel): + contracts: Optional[List[ComposerContractMeta]] = None + + class ListContractsResponseContent(BaseModel): owned: List[ContractSummaryItem] shared: List[ContractSummaryItem] +class SectionUnion1(BaseModel): + term: TermSection + + +class SectionUnion2(BaseModel): + clause: ClauseSection + + +class SectionUnion(RootModel[Union[SectionUnion1, SectionUnion2]]): + root: Union[SectionUnion1, SectionUnion2] + + class ShareContractResponseContent(BaseModel): success: bool contractId: str = Field(..., pattern='^[A-Za-z0-9-]+$') @@ -300,12 +410,38 @@ class SignContractResponseContent(BaseModel): message: Optional[str] = None -class GetContractResponseContent(BaseModel): - contractId: str = Field(..., pattern='^[A-Za-z0-9-]+$') - name: str - type: ContractType - terms: Any - iq_qa: QASections - isOwner: bool - ownerId: str = Field(..., pattern='^[A-Za-z0-9-]+$') - sharedWith: List[SharedWithItem] +class UpdateComposerContractContentRequestContent(BaseModel): + contractId: str = Field(..., pattern='^[A-Fa-f0-9-]{36}$') + sections: Optional[List[SectionUnion]] = None + + +class UpdateComposerContractMetaRequestContent(BaseModel): + contractId: str = Field(..., pattern='^[A-Fa-f0-9-]{36}$') + title: Optional[str] = None + sections: Optional[List[SectionUnion]] = None + status: Optional[ComposerContractStatus] = None + + +class ComposerContractContent(BaseModel): + sections: Optional[List[SectionUnion]] = None + + +class ComposerContractData(BaseModel): + meta: Optional[ComposerContractMeta] = None + content: Optional[ComposerContractContent] = None + + +class CreateComposerContractResponseContent(BaseModel): + contract: Optional[ComposerContractData] = None + + +class GetComposerContractContentResponseContent(BaseModel): + content: Optional[ComposerContractContent] = None + + +class UpdateComposerContractContentResponseContent(BaseModel): + contract: Optional[ComposerContractData] = None + + +class UpdateComposerContractMetaResponseContent(BaseModel): + contract: Optional[ComposerContractData] = None diff --git a/typescript/src/index.ts b/typescript/src/index.ts index 3bd359e..7d601b6 100644 --- a/typescript/src/index.ts +++ b/typescript/src/index.ts @@ -12,18 +12,34 @@ type SchemaNames = keyof components['schemas']; type ExtractSchema = components['schemas'][K]; export type AccountType = ExtractSchema<'AccountType'> +export type ArchiveComposerContractRequestContent = ExtractSchema<'ArchiveComposerContractRequestContent'> +export type ArchiveComposerContractResponseContent = ExtractSchema<'ArchiveComposerContractResponseContent'> export type AuthenticationErrorResponseContent = ExtractSchema<'AuthenticationErrorResponseContent'> +export type ClauseSection = ExtractSchema<'ClauseSection'> +export type ComposerContractContent = ExtractSchema<'ComposerContractContent'> +export type ComposerContractData = ExtractSchema<'ComposerContractData'> +export type ComposerContractMeta = ExtractSchema<'ComposerContractMeta'> +export type ComposerContractSection = ExtractSchema<'ComposerContractSection'> +export type ComposerContractStatus = ExtractSchema<'ComposerContractStatus'> +export type ComposerContractType = ExtractSchema<'ComposerContractType'> +export type ComposerFormData = ExtractSchema<'ComposerFormData'> export type ContractSignature = ExtractSchema<'ContractSignature'> export type ContractStatus = ExtractSchema<'ContractStatus'> export type ContractSummaryItem = ExtractSchema<'ContractSummaryItem'> export type ContractType = ExtractSchema<'ContractType'> +export type CreateComposerContractRequestContent = ExtractSchema<'CreateComposerContractRequestContent'> +export type CreateComposerContractResponseContent = ExtractSchema<'CreateComposerContractResponseContent'> export type DeleteContractRequestContent = ExtractSchema<'DeleteContractRequestContent'> export type DeleteContractResponseContent = ExtractSchema<'DeleteContractResponseContent'> +export type DeleteContractSignatureRequestContent = ExtractSchema<'DeleteContractSignatureRequestContent'> +export type DeleteContractSignatureResponseContent = ExtractSchema<'DeleteContractSignatureResponseContent'> export type ExposeTypesResponseContent = ExtractSchema<'ExposeTypesResponseContent'> export type FixedTermValue = ExtractSchema<'FixedTermValue'> export type FixedValueTermInference = ExtractSchema<'FixedValueTermInference'> -export type DeleteContractSignatureRequestContent = ExtractSchema<'DeleteContractSignatureRequestContent'> -export type DeleteContractSignatureResponseContent = ExtractSchema<'DeleteContractSignatureResponseContent'> +export type GetComposerContractContentRequestContent = ExtractSchema<'GetComposerContractContentRequestContent'> +export type GetComposerContractContentResponseContent = ExtractSchema<'GetComposerContractContentResponseContent'> +export type GetComposerContractMetaRequestContent = ExtractSchema<'GetComposerContractMetaRequestContent'> +export type GetComposerContractMetaResponseContent = ExtractSchema<'GetComposerContractMetaResponseContent'> export type GetContractReadURLRequestContent = ExtractSchema<'GetContractReadURLRequestContent'> export type GetContractReadURLResponseContent = ExtractSchema<'GetContractReadURLResponseContent'> export type GetContractRequestContent = ExtractSchema<'GetContractRequestContent'> @@ -37,6 +53,9 @@ export type GetProfileResponseContent = ExtractSchema<'GetProfileResponseContent export type GetUploadURLRequestContent = ExtractSchema<'GetUploadURLRequestContent'> export type GetUploadURLResponseContent = ExtractSchema<'GetUploadURLResponseContent'> export type InternalServerErrorResponseContent = ExtractSchema<'InternalServerErrorResponseContent'> +export type ListComposerContractVersionsRequestContent = ExtractSchema<'ListComposerContractVersionsRequestContent'> +export type ListComposerContractVersionsResponseContent = ExtractSchema<'ListComposerContractVersionsResponseContent'> +export type ListComposerContractsResponseContent = ExtractSchema<'ListComposerContractsResponseContent'> export type ListContractsResponseContent = ExtractSchema<'ListContractsResponseContent'> export type PingResponseContent = ExtractSchema<'PingResponseContent'> export type PresignedPostData = ExtractSchema<'PresignedPostData'> @@ -44,14 +63,22 @@ export type ProcessingIncompleteErrorResponseContent = ExtractSchema<'Processing export type QA = ExtractSchema<'QA'> export type QASection = ExtractSchema<'QASection'> export type ResourceNotFoundErrorResponseContent = ExtractSchema<'ResourceNotFoundErrorResponseContent'> +export type SaveComposerContractToVaultRequestContent = ExtractSchema<'SaveComposerContractToVaultRequestContent'> +export type SaveComposerContractToVaultResponseContent = ExtractSchema<'SaveComposerContractToVaultResponseContent'> +export type SectionUnion = ExtractSchema<'SectionUnion'> export type ShareContractRequestContent = ExtractSchema<'ShareContractRequestContent'> export type ShareContractResponseContent = ExtractSchema<'ShareContractResponseContent'> export type SharedUserDetails = ExtractSchema<'SharedUserDetails'> -export type Term = ExtractSchema<'Term'> export type SignContractRequestContent = ExtractSchema<'SignContractRequestContent'> export type SignContractResponseContent = ExtractSchema<'SignContractResponseContent'> export type SignContractResult = ExtractSchema<'SignContractResult'> export type SignatureStatus = ExtractSchema<'SignatureStatus'> +export type Term = ExtractSchema<'Term'> +export type TermSection = ExtractSchema<'TermSection'> +export type UpdateComposerContractContentRequestContent = ExtractSchema<'UpdateComposerContractContentRequestContent'> +export type UpdateComposerContractContentResponseContent = ExtractSchema<'UpdateComposerContractContentResponseContent'> +export type UpdateComposerContractMetaRequestContent = ExtractSchema<'UpdateComposerContractMetaRequestContent'> +export type UpdateComposerContractMetaResponseContent = ExtractSchema<'UpdateComposerContractMetaResponseContent'> export type UpdateContractRequestContent = ExtractSchema<'UpdateContractRequestContent'> export type UpdateContractResponseContent = ExtractSchema<'UpdateContractResponseContent'> export type UpdateProfileRequestContent = ExtractSchema<'UpdateProfileRequestContent'> diff --git a/typescript/src/models.ts b/typescript/src/models.ts index 7d6f5ac..439a4c1 100644 --- a/typescript/src/models.ts +++ b/typescript/src/models.ts @@ -4,6 +4,150 @@ */ export interface paths { + "/composer/archive": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post: operations["ArchiveComposerContract"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/composer/create": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post: operations["CreateComposerContract"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/composer/getContent": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post: operations["GetComposerContractContent"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/composer/getMeta": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post: operations["GetComposerContractMeta"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/composer/list": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post: operations["ListComposerContracts"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/composer/listVersions": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post: operations["ListComposerContractVersions"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/composer/publish": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post: operations["SaveComposerContractToVault"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/composer/updateContent": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post: operations["UpdateComposerContractContent"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/composer/updateMeta": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post: operations["UpdateComposerContractMeta"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; "/deleteContract": { parameters: { query?: never; @@ -282,9 +426,49 @@ export interface components { schemas: { /** @enum {string} */ AccountType: AccountType; + ArchiveComposerContractRequestContent: { + contractId: string; + }; + ArchiveComposerContractResponseContent: { + message: string; + }; AuthenticationErrorResponseContent: { message: string; }; + ClauseSection: { + sectionId?: components["schemas"]["ComposerContractSection"]; + text?: string; + }; + ComposerContractContent: { + sections?: components["schemas"]["SectionUnion"][]; + }; + ComposerContractData: { + meta?: components["schemas"]["ComposerContractMeta"]; + content?: components["schemas"]["ComposerContractContent"]; + }; + ComposerContractMeta: { + contractId?: string; + revisionId?: string; + title?: string; + type?: components["schemas"]["ComposerContractType"]; + status?: components["schemas"]["ComposerContractStatus"]; + /** Format: double */ + createdAt?: number; + /** Format: double */ + updatedAt?: number; + revisionHistory?: string[]; + }; + /** @enum {string} */ + ComposerContractSection: ComposerContractSection; + /** @enum {string} */ + ComposerContractStatus: ComposerContractStatus; + /** @enum {string} */ + ComposerContractType: ComposerContractType; + ComposerFormData: { + clientName?: string; + providerName?: string; + date?: string; + }; ContractSignature: { userId?: string; status?: components["schemas"]["SignatureStatus"]; @@ -305,15 +489,32 @@ export interface components { sharedWith?: string[]; sharedUsers?: string[]; sharedEmails?: string[]; + isComposerGenerated?: boolean; }; /** @enum {string} */ ContractType: ContractType; + CreateComposerContractRequestContent: { + title: string; + type: components["schemas"]["ComposerContractType"]; + formDetails?: components["schemas"]["ComposerFormData"]; + sourceRevisionId?: string; + }; + CreateComposerContractResponseContent: { + contract?: components["schemas"]["ComposerContractData"]; + }; DeleteContractRequestContent: { contractId: string; }; DeleteContractResponseContent: { success: boolean; }; + DeleteContractSignatureRequestContent: { + contractId: string; + }; + DeleteContractSignatureResponseContent: { + result?: components["schemas"]["SignContractResult"]; + message?: string; + }; ExposeTypesResponseContent: { QASectionsList?: components["schemas"]["QASection"][]; }; @@ -329,12 +530,17 @@ export interface components { primary: components["schemas"]["FixedTermValue"]; subterms?: components["schemas"]["FixedTermValue"][]; }; - DeleteContractSignatureRequestContent: { + GetComposerContractContentRequestContent: { contractId: string; }; - DeleteContractSignatureResponseContent: { - result?: components["schemas"]["SignContractResult"]; - message?: string; + GetComposerContractContentResponseContent: { + content?: components["schemas"]["ComposerContractContent"]; + }; + GetComposerContractMetaRequestContent: { + contractId: string; + }; + GetComposerContractMetaResponseContent: { + meta?: components["schemas"]["ComposerContractMeta"]; }; GetContractReadURLRequestContent: { contractId: string; @@ -384,6 +590,16 @@ export interface components { InternalServerErrorResponseContent: { message: string; }; + ListComposerContractVersionsRequestContent: { + contractId: string; + }; + ListComposerContractVersionsResponseContent: { + contractId?: string; + versions?: components["schemas"]["ComposerContractMeta"][]; + }; + ListComposerContractsResponseContent: { + contracts?: components["schemas"]["ComposerContractMeta"][]; + }; ListContractsResponseContent: { owned: components["schemas"]["ContractSummaryItem"][]; shared: components["schemas"]["ContractSummaryItem"][]; @@ -409,6 +625,17 @@ export interface components { ResourceNotFoundErrorResponseContent: { message: string; }; + SaveComposerContractToVaultRequestContent: { + contractId: string; + }; + SaveComposerContractToVaultResponseContent: { + message: string; + }; + SectionUnion: { + term: components["schemas"]["TermSection"]; + } | { + clause: components["schemas"]["ClauseSection"]; + }; ShareContractRequestContent: { contractId: string; emailsToAdd?: string[]; @@ -428,13 +655,6 @@ export interface components { /** Format: double */ sharedTime: number; }; - Term: { - name: string; - definition: string; - unitType: string; - citation?: string; - fixedValues?: components["schemas"]["FixedValueTermInference"]; - }; SignContractRequestContent: { contractId: string; status: components["schemas"]["SignatureStatus"]; @@ -444,9 +664,39 @@ export interface components { message?: string; }; /** @enum {string} */ - SignContractResult: "SUCCESS" | "FAILURE"; + SignContractResult: SignContractResult; /** @enum {string} */ - SignatureStatus: "signed" | "declined" | "pending"; + SignatureStatus: SignatureStatus; + Term: { + name: string; + definition: string; + unitType: string; + citation?: string; + fixedValues?: components["schemas"]["FixedValueTermInference"]; + }; + TermSection: { + sectionId?: components["schemas"]["ComposerContractSection"]; + name?: string; + definition?: string; + citation?: string; + unit?: string; + }; + UpdateComposerContractContentRequestContent: { + contractId: string; + sections?: components["schemas"]["SectionUnion"][]; + }; + UpdateComposerContractContentResponseContent: { + contract?: components["schemas"]["ComposerContractData"]; + }; + UpdateComposerContractMetaRequestContent: { + contractId: string; + title?: string; + sections?: components["schemas"]["SectionUnion"][]; + status?: components["schemas"]["ComposerContractStatus"]; + }; + UpdateComposerContractMetaResponseContent: { + contract?: components["schemas"]["ComposerContractData"]; + }; UpdateContractRequestContent: { contractId: string; name: string; @@ -505,6 +755,236 @@ export interface components { } export type $defs = Record; export interface operations { + ArchiveComposerContract: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody: { + content: { + "application/json": components["schemas"]["ArchiveComposerContractRequestContent"]; + }; + }; + responses: { + /** @description ArchiveComposerContract 200 response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ArchiveComposerContractResponseContent"]; + }; + }; + /** @description ResourceNotFoundError 400 response */ + 400: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ResourceNotFoundErrorResponseContent"]; + }; + }; + /** @description InternalServerError 500 response */ + 500: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["InternalServerErrorResponseContent"]; + }; + }; + }; + }; + CreateComposerContract: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody: { + content: { + "application/json": components["schemas"]["CreateComposerContractRequestContent"]; + }; + }; + responses: { + /** @description CreateComposerContract 200 response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["CreateComposerContractResponseContent"]; + }; + }; + }; + }; + GetComposerContractContent: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody: { + content: { + "application/json": components["schemas"]["GetComposerContractContentRequestContent"]; + }; + }; + responses: { + /** @description GetComposerContractContent 200 response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["GetComposerContractContentResponseContent"]; + }; + }; + }; + }; + GetComposerContractMeta: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody: { + content: { + "application/json": components["schemas"]["GetComposerContractMetaRequestContent"]; + }; + }; + responses: { + /** @description GetComposerContractMeta 200 response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["GetComposerContractMetaResponseContent"]; + }; + }; + }; + }; + ListComposerContracts: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody?: never; + responses: { + /** @description ListComposerContracts 200 response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ListComposerContractsResponseContent"]; + }; + }; + }; + }; + ListComposerContractVersions: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody: { + content: { + "application/json": components["schemas"]["ListComposerContractVersionsRequestContent"]; + }; + }; + responses: { + /** @description ListComposerContractVersions 200 response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["ListComposerContractVersionsResponseContent"]; + }; + }; + }; + }; + SaveComposerContractToVault: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody: { + content: { + "application/json": components["schemas"]["SaveComposerContractToVaultRequestContent"]; + }; + }; + responses: { + /** @description SaveComposerContractToVault 200 response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["SaveComposerContractToVaultResponseContent"]; + }; + }; + }; + }; + UpdateComposerContractContent: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody: { + content: { + "application/json": components["schemas"]["UpdateComposerContractContentRequestContent"]; + }; + }; + responses: { + /** @description UpdateComposerContractContent 200 response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["UpdateComposerContractContentResponseContent"]; + }; + }; + }; + }; + UpdateComposerContractMeta: { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + requestBody: { + content: { + "application/json": components["schemas"]["UpdateComposerContractMetaRequestContent"]; + }; + }; + responses: { + /** @description UpdateComposerContractMeta 200 response */ + 200: { + headers: { + [name: string]: unknown; + }; + content: { + "application/json": components["schemas"]["UpdateComposerContractMetaResponseContent"]; + }; + }; + }; + }; DeleteContract: { parameters: { query?: never; @@ -1179,6 +1659,22 @@ export enum AccountType { producer = "producer", publisher = "publisher" } +export enum ComposerContractSection { + SERVICES = "SERVICES", + COMPENSATION = "COMPENSATION", + INTELLECTUAL_PROPERTY = "INTELLECTUAL_PROPERTY", + TERM_AND_TERMINATION = "TERM_AND_TERMINATION", + CONFIDENTIALITY = "CONFIDENTIALITY" +} +export enum ComposerContractStatus { + NEW = "NEW", + CLEAN_IN_VAULT = "CLEAN_IN_VAULT", + DIRTY = "DIRTY", + ARCHIVED = "ARCHIVED" +} +export enum ComposerContractType { + PRODUCER = "PRODUCER" +} export enum ContractStatus { processing = "processing", complete = "complete", @@ -1192,3 +1688,12 @@ export enum ContractType { producer = "producer", tbd = "tbd" } +export enum SignContractResult { + SUCCESS = "SUCCESS", + FAILURE = "FAILURE" +} +export enum SignatureStatus { + signed = "signed", + declined = "declined", + pending = "pending" +}