@jumoo/usync-publisher-assets 0.0.0-stage → 18.3.0

package/dist/api/types.gen.d.ts

@@ -0,0 +1,2070 @@
+export type ClientOptions = {
+    baseUrl: 'https://localhost:44385/' | (string & {});
+};
+export type AppKeySetupResult = {
+    appId: string;
+    appKey: string;
+    json: string;
+};
+export type AppKeyView = {
+    appId?: null | string;
+    appKey?: null | string;
+};
+export type BadRequest = {
+    statusCode: number | string;
+};
+export type BatchPushAddResult = {
+    added: number | string;
+    total: number | string;
+};
+export type BatchPushIncludeChildrenRequest = {
+    udi: string;
+    includeChildren: boolean;
+};
+export type BatchPushItemModel = {
+    udi: string;
+    entityType: string;
+    name: string;
+    icon?: null | string;
+    path: string;
+    includeChildren: boolean;
+    isRoot: boolean;
+    exists: boolean;
+    added: string;
+};
+export type BatchPushItemRequest = {
+    udi: string;
+    entityType: string;
+    includeChildren: boolean;
+};
+export type BatchPushModel = {
+    items: Array<BatchPushItemModel>;
+    servers: Array<SyncPublishServerView>;
+};
+export declare enum ChangeDetailType {
+    NO_CHANGE = "NoChange",
+    CREATE = "Create",
+    UPDATE = "Update",
+    DELETE = "Delete",
+    ERROR = "Error",
+    WARNING = "Warning"
+}
+export declare enum ChangeType {
+    NO_CHANGE = "NoChange",
+    CREATE = "Create",
+    IMPORT = "Import",
+    EXPORT = "Export",
+    UPDATE = "Update",
+    DELETE = "Delete",
+    WILL_CHANGE = "WillChange",
+    INFORMATION = "Information",
+    ROLLEDBACK = "Rolledback",
+    FAIL = "Fail",
+    IMPORT_FAIL = "ImportFail",
+    MISMATCH = "Mismatch",
+    PARENT_MISSING = "ParentMissing",
+    HIDDEN = "Hidden",
+    CLEAN = "Clean",
+    REMOVED = "Removed"
+}
+export type CustomPublisherOptions = {
+    releaseDate?: null | string;
+    approvalNote?: null | string;
+};
+export type DependencyFlags = string;
+export type FlagModel = {
+    alias: string;
+};
+export type PagedModelPublisherApprovalSummaryModel = {
+    items: Array<PublisherApprovalSummaryModel>;
+    total: number | string;
+};
+export type PagedSyncServerItemResponseModel = {
+    total: number | string;
+    items: Array<SyncServerItemResponseModel>;
+};
+export type PipelineRunRejected = {
+    reason: PipelineRunRejectedReason;
+    message: string;
+    runningPipelineId?: null | string;
+    concurrencyKey?: null | string;
+};
+export declare enum PipelineRunRejectedReason {
+    NOT_FOUND = "NotFound",
+    ALREADY_RUNNING = "AlreadyRunning",
+    INVALID = "Invalid",
+    NOT_WAITING = "NotWaiting"
+}
+export type PipelineRunStarted = {
+    pipelineId: string;
+    status: PipelineRunState;
+    statusUrl: string;
+};
+export declare enum PipelineRunState {
+    QUEUED = "Queued",
+    RUNNING = "Running",
+    SCHEDULED = "Scheduled",
+    WAITING = "Waiting",
+    COMPLETED = "Completed",
+    FAILED = "Failed",
+    CANCELLED = "Cancelled"
+}
+export type ProblemDetails = {
+    type?: null | string;
+    title?: null | string;
+    status?: null | number | string;
+    detail?: null | string;
+    instance?: null | string;
+};
+export type PublisherApprovalAccessModel = {
+    inUse: boolean;
+    isApprover: boolean;
+};
+export type PublisherApprovalDecisionModel = {
+    key: string;
+    comment?: null | string;
+};
+export type PublisherApprovalDetailModel = {
+    pipelineId: string;
+    message?: null | string;
+    decisionComment?: null | string;
+    error?: null | string;
+    report: Array<USyncActionView>;
+    appliedReport?: null | Array<USyncActionView>;
+    result?: null | Array<USyncActionView>;
+    finished?: null | string;
+    progress?: null | PublisherApprovalProgress;
+    canDecide: boolean;
+    cannotDecideReason?: null | string;
+    canWithdraw: boolean;
+    key: string;
+    serverAlias: string;
+    serverName: string;
+    serverIcon: string;
+    mode: PublishMode;
+    status: PublisherApprovalStatus;
+    requestedByName: string;
+    requested: string;
+    items: Array<PublisherApprovalItem>;
+    changes: number | string;
+    decidedByName?: null | string;
+    decided?: null | string;
+    expires?: null | string;
+    reportChanged: boolean;
+};
+export type PublisherApprovalItem = {
+    name: string;
+    icon?: null | string;
+    udi: string;
+    entityType?: null | string;
+};
+export type PublisherApprovalProgress = {
+    percentage: number | string;
+    action?: null | string;
+    step?: null | string;
+};
+export type PublisherApprovalServerModel = {
+    requiresApproval: boolean;
+    isApprover: boolean;
+};
+export declare enum PublisherApprovalStatus {
+    PENDING = "Pending",
+    APPROVED = "Approved",
+    DECLINED = "Declined",
+    EXPIRED = "Expired",
+    APPLIED = "Applied",
+    FAILED = "Failed",
+    CANCELLED = "Cancelled"
+}
+export type PublisherApprovalSummaryModel = {
+    key: string;
+    serverAlias: string;
+    serverName: string;
+    serverIcon: string;
+    mode: PublishMode;
+    status: PublisherApprovalStatus;
+    requestedByName: string;
+    requested: string;
+    items: Array<PublisherApprovalItem>;
+    changes: number | string;
+    decidedByName?: null | string;
+    decided?: null | string;
+    expires?: null | string;
+    reportChanged: boolean;
+};
+export type PublisherProcessingOptions = {
+    mode: PublishMode;
+    server?: null | string;
+    entityType?: null | string;
+    items: Array<SyncItem>;
+    publisherOptions?: null | SyncPublisherOptions;
+    isBackgroundRequest?: null | boolean;
+    pageSize?: null | number | string;
+    createRestorePoint: boolean;
+    handlerGroup?: null | string;
+    handlerSet?: null | string;
+    siteAssemblyName?: null | string;
+    custom?: null | CustomPublisherOptions;
+    cultures?: null | Array<string>;
+    sourceAction: SyncProcessingSourceAction;
+    sourceSendSettings?: null | PublisherSyncSendOptions;
+};
+export type PublisherStartItem = {
+    udi: string;
+    includeChildren: boolean;
+};
+export declare enum PublisherStartMode {
+    PUSH = "Push",
+    PULL = "Pull",
+    SETTINGS_PUSH = "SettingsPush",
+    SETTINGS_PULL = "SettingsPull"
+}
+export type PublisherStartOptions = {
+    includeDependencies: boolean;
+    includeMedia: boolean;
+    includeMediaFiles: boolean;
+    includeAncestors: boolean;
+    createRestorePoint: boolean;
+    cultures: Array<string>;
+};
+export type PublisherStartRequest = {
+    mode: PublisherStartMode;
+    server: string;
+    items: Array<PublisherStartItem>;
+    entityType?: null | string;
+    options: PublisherStartOptions;
+    startAtUtc?: null | string;
+};
+export type PublisherSyncSendOptions = {
+    autoExpandAdvanced?: null | boolean;
+    includeAncestors?: null | SyncSendOption;
+    includeChildren?: null | SyncSendOption;
+    includeFiles?: null | SyncSendOption;
+    includeMedia?: null | SyncSendOption;
+    includeLinked?: null | SyncSendOption;
+    includeDependencies?: null | SyncSendOption;
+    includeMediaFiles?: null | SyncSendOption;
+    includeConfig?: null | SyncSendOption;
+    deleteMissing?: null | SyncSendOption;
+    createRestorePoint?: null | SyncSendOption;
+    showScheduledOptions?: null | boolean;
+    sendEditedValue?: null | boolean;
+    publishFallback?: null | boolean;
+    message?: null | string;
+    ignoreSortOrder?: null | boolean;
+    detectRestorePoint?: null | boolean;
+    hideAdvanced?: null | boolean;
+    requireApproval?: null | boolean;
+    approverGroups?: null | Array<string>;
+    approvalExpiryDays?: null | number | string;
+    allowBatchPush?: null | boolean;
+};
+export declare enum PublishMode {
+    PUSH = "Push",
+    PULL = "Pull",
+    PUSH_MEDIA = "PushMedia",
+    PULL_MEDIA = "PullMedia",
+    REPORT = "Report",
+    CONFIG_PUSH = "ConfigPush",
+    CONFIG_PULL = "ConfigPull",
+    SETTINGS_PUSH = "SettingsPush",
+    SETTINGS_PULL = "SettingsPull",
+    FILE_PUSH = "FilePush",
+    FILE_PULL = "FilePull",
+    SEED = "Seed",
+    SYNC_SETUP = "SyncSetup",
+    ANY = "Any"
+}
+export type ReferenceByIdModel = {
+    id: string;
+};
+export type ServerSyncRequest = {
+    servers: Array<string>;
+};
+export type ServerSyncResult = {
+    success: boolean;
+    servers: {
+        [key: string]: boolean;
+    };
+};
+export type SiteSeedStatus = {
+    isEnabled: boolean;
+    seedServerUrl: string;
+    hasContentOrMedia: boolean;
+};
+export type SplitEntityView = {
+    local?: null | USyncEntityView;
+    remote?: null | USyncEntityView;
+};
+export type SyncBrowserItemChange = {
+    udi?: null | UdiModel;
+    action: USyncActionView;
+};
+export type SyncEntity = {
+    name: string;
+    icon?: null | string;
+    udi: UdiModel;
+    entityType: null | string;
+};
+export type SyncItem = {
+    flags: DependencyFlags;
+    change: ChangeType;
+    name: string;
+    icon?: null | string;
+    udi: UdiModel;
+    entityType: null | string;
+};
+export type SyncLocalItem = {
+    id?: null | string;
+    name?: null | string;
+    udi?: null | UdiModel;
+    entityType?: null | string;
+    allVariants: {
+        [key: string]: SyncVariantInfo;
+    };
+    requiresFiles: boolean;
+    hasChildren: boolean;
+};
+export declare enum SyncProcessingSourceAction {
+    DEFAULT = "Default",
+    PUBLISH = "Publish",
+    PUBLISH_DECENDANTS = "PublishDecendants",
+    SCHEDULE = "Schedule",
+    ADD_TO_QUEUE = "AddToQueue",
+    API = "Api",
+    BATCH_PUSH = "BatchPush"
+}
+export type SyncPublishAvailableServerRequest = {
+    mode: PublishMode;
+    udi?: null | string;
+    entityType?: null | string;
+    enabledOnly: boolean;
+};
+export type SyncPublisherObjects = {
+    options?: null | PublisherProcessingOptions;
+    item?: null | SyncItem;
+};
+export type SyncPublisherOptions = {
+    includeChildren: boolean;
+    includeAncestors: boolean;
+    includeDependencies: boolean;
+    includeMedia: boolean;
+    includeViews: boolean;
+    includeLinked: boolean;
+    includeConfig: boolean;
+    rootSync: boolean;
+    includeContents: boolean;
+    publishedDependencies: boolean;
+    primaryType?: null | string;
+    removeOrphans: boolean;
+    includeFiles: boolean;
+    includeFileHash: boolean;
+    includeContent: boolean;
+    includeSystemFileHash: boolean;
+    includeSystemFiles: boolean;
+    includeMediaFiles: boolean;
+    cultures: Array<string>;
+    custom: {
+        [key: string]: string;
+    };
+    enableRollback: boolean;
+    createRestorePoint: boolean;
+    skipReport: boolean;
+};
+export type SyncPublisherVariantsResult = {
+    name: string;
+    displayName: string;
+    isPublished: boolean;
+    selected: boolean;
+};
+export type SyncPublishServerCopyView = {
+    alias: string;
+    name: string;
+    url: string;
+};
+export type SyncPublishServerView = {
+    key: string;
+    id: string;
+    alias: string;
+    enabled: boolean;
+    pullEnabled: boolean;
+    name: string;
+    description?: null | string;
+    icon: string;
+    url: string;
+    baseUrl?: null | string;
+    sortOrder: number | string;
+    publisher: string;
+    allowedServers?: null | Array<USyncAllowedServer>;
+    sendSettings?: null | SyncSendOptions;
+    publisherSettings: {
+        [key: string]: unknown;
+    };
+    publisherConfig?: null | string;
+    userGroups: Array<string>;
+    allowBatchPush: boolean;
+    appearance: SyncServerAppearance;
+};
+export type SyncSendOption = {
+    value: boolean;
+    editable: boolean;
+};
+export type SyncSendOptions = {
+    includeAncestors?: null | SyncSendOption;
+    includeChildren?: null | SyncSendOption;
+    includeFiles?: null | SyncSendOption;
+    includeMedia?: null | SyncSendOption;
+    includeLinked?: null | SyncSendOption;
+    includeDependencies?: null | SyncSendOption;
+    includeMediaFiles?: null | SyncSendOption;
+    includeConfig?: null | SyncSendOption;
+    deleteMissing?: null | SyncSendOption;
+    createRestorePoint?: null | SyncSendOption;
+    showScheduledOptions?: null | boolean;
+    sendEditedValue?: null | boolean;
+    publishFallback?: null | boolean;
+    message?: null | string;
+    ignoreSortOrder?: null | boolean;
+    detectRestorePoint?: null | boolean;
+    hideAdvanced?: null | boolean;
+    requireApproval?: null | boolean;
+    approverGroups?: null | Array<string>;
+    approvalExpiryDays?: null | number | string;
+    allowBatchPush?: null | boolean;
+};
+export type SyncServerAppearance = {
+    icon: string;
+    color?: null | string;
+    applyColourToNavbar?: null | boolean;
+    hidePublishButton?: null | boolean;
+    hideSaveAndPreviewButton?: null | boolean;
+    hideSaveButton?: null | boolean;
+    hideSaveAndPublishButton?: null | boolean;
+    hideSchedulePublishingButton?: null | boolean;
+    hidePublishDecendantsButton?: null | boolean;
+    hideUnpublishButton?: null | boolean;
+    hideCompareTab?: null | boolean;
+    showServerIdentifier?: null | boolean;
+};
+export type SyncServerItemResponseModel = {
+    icon: string;
+    type: string;
+    name: string;
+    id: string;
+    parent?: null | ReferenceByIdModel;
+    flags: Array<FlagModel>;
+    hasChildren: boolean;
+};
+export declare enum SyncServerStatus {
+    UNKNOWN = "Unknown",
+    UNAVAILABLE = "Unavailable",
+    UNREACHABLE = "Unreachable",
+    UNAUTHORIZED = "Unauthorized",
+    SERVER_ERROR = "ServerError",
+    DISABLED = "Disabled",
+    API_MISMATCH = "ApiMismatch",
+    UNLICENCED = "Unlicenced",
+    NOT_ENABLED = "NotEnabled",
+    UNKNOWN_SERVER = "UnknownServer",
+    NO_PUBLISHER = "NoPublisher",
+    NOT_FOUND = "NotFound",
+    INVALID_RESPONSE = "InvalidResponse",
+    NOT_CHECKED = "NotChecked",
+    BLOCKED = "Blocked",
+    NOT_REPORTED = "NotReported",
+    SUCCESS = "Success"
+}
+export type SyncServerTemplateModel = {
+    id?: null | string;
+    icon?: null | string;
+    heading?: null | string;
+    subHeading?: null | string;
+    description?: null | string;
+    publisher?: null | string;
+    publisherConfig?: null | string;
+    flags?: null | SyncSendOptions;
+};
+export type SyncVariantInfo = {
+    name?: null | string;
+    published: boolean;
+};
+export type UdiModel = {
+    uriValue: null | string;
+    entityType: null | string;
+    isRoot: boolean;
+};
+export type UserGroupListModel = {
+    key: string;
+    alias: string;
+    name: string;
+    icon: string;
+};
+export type USyncActionView = {
+    key: string;
+    name: string;
+    handler: string;
+    itemType: string;
+    change: ChangeType;
+    success: boolean;
+    details: Array<USyncChange>;
+    message?: null | string;
+};
+export type USyncAllowedServer = {
+    name: string;
+    icon: string;
+    alias: string;
+    push: boolean;
+    pull: boolean;
+};
+export type USyncChange = {
+    success: boolean;
+    name: string;
+    path: string;
+    oldValue: string;
+    newValue: string;
+    change: ChangeDetailType;
+};
+export type USyncEntityVariant = {
+    name: string;
+};
+export type USyncEntityView = {
+    id: number | string;
+    name: string;
+    key: string;
+    udi?: null | UdiModel;
+    icon?: null | string;
+    type?: null | string;
+    thumbnail?: null | string;
+    isFolder: boolean;
+    hasChildren: boolean;
+    extension?: null | string;
+    height: number | string;
+    width: number | string;
+    update: string;
+    localUrl?: null | string;
+    mediaProperty?: null | string;
+    remoteUrl?: null | string;
+    variants?: null | Array<USyncEntityVariant>;
+    localItem?: null | SyncLocalItem;
+    exisitsLocally: boolean;
+};
+export type USyncItemFolder = {
+    key: string;
+    path: Array<USyncPathItem>;
+    folders: Array<USyncEntityView>;
+    nodes: Array<USyncEntityView>;
+    total: number | string;
+    pages: number | string;
+};
+export type USyncPathItem = {
+    name: string;
+    key: string;
+};
+export type USyncPublisherView = {
+    name: string;
+    alias: string;
+    description: string;
+    configElement: null | string;
+};
+export type USyncPublishServerStatus = {
+    enabled: boolean;
+    status: SyncServerStatus;
+    message?: null | string;
+};
+export type USyncPublishSettingsView = {
+    outgoingEnabled: boolean;
+    incomingEnabled: boolean;
+    server?: null | SyncPublishServerView;
+    hasAppId: boolean;
+    serverUrl: string;
+    serverName: string;
+    serverAlias: string;
+    isInList: boolean;
+};
+export type ApproveData = {
+    body: PublisherApprovalDecisionModel;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/Approve';
+};
+export type ApproveErrors = {
+    /**
+     * Bad Request
+     */
+    400: ProblemDetails;
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type ApproveError = ApproveErrors[keyof ApproveErrors];
+export type ApproveResponses = {
+    /**
+     * OK
+     */
+    200: PublisherApprovalDetailModel;
+};
+export type ApproveResponse = ApproveResponses[keyof ApproveResponses];
+export type DeclineData = {
+    body: PublisherApprovalDecisionModel;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/Decline';
+};
+export type DeclineErrors = {
+    /**
+     * Bad Request
+     */
+    400: ProblemDetails;
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type DeclineError = DeclineErrors[keyof DeclineErrors];
+export type DeclineResponses = {
+    /**
+     * OK
+     */
+    200: PublisherApprovalDetailModel;
+};
+export type DeclineResponse = DeclineResponses[keyof DeclineResponses];
+export type GetApprovalData = {
+    body?: never;
+    path?: never;
+    query?: {
+        key?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetApproval';
+};
+export type GetApprovalErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Not Found
+     */
+    404: ProblemDetails;
+};
+export type GetApprovalError = GetApprovalErrors[keyof GetApprovalErrors];
+export type GetApprovalResponses = {
+    /**
+     * OK
+     */
+    200: PublisherApprovalDetailModel;
+};
+export type GetApprovalResponse = GetApprovalResponses[keyof GetApprovalResponses];
+export type GetApprovalAccessData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/GetApprovalAccess';
+};
+export type GetApprovalAccessErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetApprovalAccessResponses = {
+    /**
+     * OK
+     */
+    200: PublisherApprovalAccessModel;
+};
+export type GetApprovalAccessResponse = GetApprovalAccessResponses[keyof GetApprovalAccessResponses];
+export type GetApprovalByPipelineData = {
+    body?: never;
+    path?: never;
+    query?: {
+        pipelineId?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetApprovalByPipeline';
+};
+export type GetApprovalByPipelineErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Not Found
+     */
+    404: ProblemDetails;
+};
+export type GetApprovalByPipelineError = GetApprovalByPipelineErrors[keyof GetApprovalByPipelineErrors];
+export type GetApprovalByPipelineResponses = {
+    /**
+     * OK
+     */
+    200: PublisherApprovalDetailModel;
+};
+export type GetApprovalByPipelineResponse = GetApprovalByPipelineResponses[keyof GetApprovalByPipelineResponses];
+export type GetApprovalHistoryData = {
+    body?: never;
+    path?: never;
+    query?: {
+        page?: number | string;
+        pageSize?: number | string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetApprovalHistory';
+};
+export type GetApprovalHistoryErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetApprovalHistoryResponses = {
+    /**
+     * OK
+     */
+    200: PagedModelPublisherApprovalSummaryModel;
+};
+export type GetApprovalHistoryResponse = GetApprovalHistoryResponses[keyof GetApprovalHistoryResponses];
+export type GetAwaitingApprovalData = {
+    body?: never;
+    path?: never;
+    query?: {
+        page?: number | string;
+        pageSize?: number | string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetAwaitingApproval';
+};
+export type GetAwaitingApprovalErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetAwaitingApprovalResponses = {
+    /**
+     * OK
+     */
+    200: PagedModelPublisherApprovalSummaryModel;
+};
+export type GetAwaitingApprovalResponse = GetAwaitingApprovalResponses[keyof GetAwaitingApprovalResponses];
+export type GetAwaitingApprovalCountData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/GetAwaitingApprovalCount';
+};
+export type GetAwaitingApprovalCountErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetAwaitingApprovalCountResponses = {
+    /**
+     * OK
+     */
+    200: number | string;
+};
+export type GetAwaitingApprovalCountResponse = GetAwaitingApprovalCountResponses[keyof GetAwaitingApprovalCountResponses];
+export type GetMyRequestsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        page?: number | string;
+        pageSize?: number | string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetMyRequests';
+};
+export type GetMyRequestsErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetMyRequestsResponses = {
+    /**
+     * OK
+     */
+    200: PagedModelPublisherApprovalSummaryModel;
+};
+export type GetMyRequestsResponse = GetMyRequestsResponses[keyof GetMyRequestsResponses];
+export type GetServerApprovalData = {
+    body?: never;
+    path?: never;
+    query?: {
+        server?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetServerApproval';
+};
+export type GetServerApprovalErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetServerApprovalResponses = {
+    /**
+     * OK
+     */
+    200: PublisherApprovalServerModel;
+};
+export type GetServerApprovalResponse = GetServerApprovalResponses[keyof GetServerApprovalResponses];
+export type WithdrawData = {
+    body: PublisherApprovalDecisionModel;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/Withdraw';
+};
+export type WithdrawErrors = {
+    /**
+     * Bad Request
+     */
+    400: ProblemDetails;
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type WithdrawError = WithdrawErrors[keyof WithdrawErrors];
+export type WithdrawResponses = {
+    /**
+     * OK
+     */
+    200: PublisherApprovalDetailModel;
+};
+export type WithdrawResponse = WithdrawResponses[keyof WithdrawResponses];
+export type AddToBatchData = {
+    body: Array<BatchPushItemRequest>;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/AddToBatch';
+};
+export type AddToBatchErrors = {
+    /**
+     * Bad Request
+     */
+    400: ProblemDetails;
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type AddToBatchError = AddToBatchErrors[keyof AddToBatchErrors];
+export type AddToBatchResponses = {
+    /**
+     * OK
+     */
+    200: BatchPushAddResult;
+};
+export type AddToBatchResponse = AddToBatchResponses[keyof AddToBatchResponses];
+export type ClearBatchData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/ClearBatch';
+};
+export type ClearBatchErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type ClearBatchResponses = {
+    /**
+     * OK
+     */
+    200: number | string;
+};
+export type ClearBatchResponse = ClearBatchResponses[keyof ClearBatchResponses];
+export type GetBatchData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/GetBatch';
+};
+export type GetBatchErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetBatchResponses = {
+    /**
+     * OK
+     */
+    200: BatchPushModel;
+};
+export type GetBatchResponse = GetBatchResponses[keyof GetBatchResponses];
+export type GetBatchCountData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/GetBatchCount';
+};
+export type GetBatchCountErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetBatchCountResponses = {
+    /**
+     * OK
+     */
+    200: number | string;
+};
+export type GetBatchCountResponse = GetBatchCountResponses[keyof GetBatchCountResponses];
+export type RemoveFromBatchData = {
+    body: Array<string>;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/RemoveFromBatch';
+};
+export type RemoveFromBatchErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type RemoveFromBatchResponses = {
+    /**
+     * OK
+     */
+    200: number | string;
+};
+export type RemoveFromBatchResponse = RemoveFromBatchResponses[keyof RemoveFromBatchResponses];
+export type SetBatchIncludeChildrenData = {
+    body: BatchPushIncludeChildrenRequest;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/SetBatchIncludeChildren';
+};
+export type SetBatchIncludeChildrenErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Not Found
+     */
+    404: ProblemDetails;
+};
+export type SetBatchIncludeChildrenError = SetBatchIncludeChildrenErrors[keyof SetBatchIncludeChildrenErrors];
+export type SetBatchIncludeChildrenResponses = {
+    /**
+     * OK
+     */
+    200: unknown;
+};
+export type CalculateContentChangesData = {
+    body: Array<UdiModel>;
+    path?: never;
+    query?: {
+        server?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/CalculateContentChanges';
+};
+export type CalculateContentChangesErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type CalculateContentChangesResponses = {
+    /**
+     * OK
+     */
+    200: Array<SyncBrowserItemChange>;
+};
+export type CalculateContentChangesResponse = CalculateContentChangesResponses[keyof CalculateContentChangesResponses];
+export type CalculateMediaChangesData = {
+    body: Array<UdiModel>;
+    path?: never;
+    query?: {
+        server?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/CalculateMediaChanges';
+};
+export type CalculateMediaChangesErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type CalculateMediaChangesResponses = {
+    /**
+     * OK
+     */
+    200: Array<SyncBrowserItemChange>;
+};
+export type CalculateMediaChangesResponse = CalculateMediaChangesResponses[keyof CalculateMediaChangesResponses];
+export type GetContentEntityData = {
+    body?: never;
+    path?: never;
+    query?: {
+        id?: string;
+        server?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetContentEntity';
+};
+export type GetContentEntityErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetContentEntityResponses = {
+    /**
+     * OK
+     */
+    200: SplitEntityView;
+};
+export type GetContentEntityResponse = GetContentEntityResponses[keyof GetContentEntityResponses];
+export type GetContentFoldersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        id?: string;
+        server?: string;
+        page?: number | string;
+        sortBy?: string;
+        sortDirection?: string;
+        search?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetContentFolders';
+};
+export type GetContentFoldersErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetContentFoldersResponses = {
+    /**
+     * OK
+     */
+    200: USyncItemFolder;
+};
+export type GetContentFoldersResponse = GetContentFoldersResponses[keyof GetContentFoldersResponses];
+export type GetLocalContentFoldersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        id?: string;
+        page?: number | string;
+        sortBy?: string;
+        sortDirection?: string;
+        search?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetLocalContentFolders';
+};
+export type GetLocalContentFoldersErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetLocalContentFoldersResponses = {
+    /**
+     * OK
+     */
+    200: USyncItemFolder;
+};
+export type GetLocalContentFoldersResponse = GetLocalContentFoldersResponses[keyof GetLocalContentFoldersResponses];
+export type GetLocalMediaFoldersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        id?: string;
+        page?: number | string;
+        sortBy?: string;
+        sortDirection?: string;
+        search?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetLocalMediaFolders';
+};
+export type GetLocalMediaFoldersErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetLocalMediaFoldersResponses = {
+    /**
+     * OK
+     */
+    200: USyncItemFolder;
+};
+export type GetLocalMediaFoldersResponse = GetLocalMediaFoldersResponses[keyof GetLocalMediaFoldersResponses];
+export type GetMediaEntityData = {
+    body?: never;
+    path?: never;
+    query?: {
+        id?: string;
+        server?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetMediaEntity';
+};
+export type GetMediaEntityErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetMediaEntityResponses = {
+    /**
+     * OK
+     */
+    200: SplitEntityView;
+};
+export type GetMediaEntityResponse = GetMediaEntityResponses[keyof GetMediaEntityResponses];
+export type GetMediaFoldersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        id?: string;
+        server?: string;
+        page?: number | string;
+        sortBy?: string;
+        sortDirection?: string;
+        search?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetMediaFolders';
+};
+export type GetMediaFoldersErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetMediaFoldersResponses = {
+    /**
+     * OK
+     */
+    200: USyncItemFolder;
+};
+export type GetMediaFoldersResponse = GetMediaFoldersResponses[keyof GetMediaFoldersResponses];
+export type HasContentData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/HasContent';
+};
+export type HasContentErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type HasContentResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type HasContentResponse = HasContentResponses[keyof HasContentResponses];
+export type HasContentOrMediaData = {
+    body?: never;
+    path?: never;
+    query?: {
+        checkEnabled?: boolean;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/HasContentOrMedia';
+};
+export type HasContentOrMediaErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type HasContentOrMediaResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type HasContentOrMediaResponse = HasContentOrMediaResponses[keyof HasContentOrMediaResponses];
+export type HasMediaData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/HasMedia';
+};
+export type HasMediaErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type HasMediaResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type HasMediaResponse = HasMediaResponses[keyof HasMediaResponses];
+export type GetVariantsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        udiValue?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetVariants';
+};
+export type GetVariantsErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetVariantsResponses = {
+    /**
+     * OK
+     */
+    200: Array<SyncPublisherVariantsResult>;
+};
+export type GetVariantsResponse = GetVariantsResponses[keyof GetVariantsResponses];
+export type CreateKeysData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/CreateKeys';
+};
+export type CreateKeysErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type CreateKeysResponses = {
+    /**
+     * OK
+     */
+    200: AppKeySetupResult;
+};
+export type CreateKeysResponse = CreateKeysResponses[keyof CreateKeysResponses];
+export type HasKeysData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/HasKeys';
+};
+export type HasKeysErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type HasKeysResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type HasKeysResponse = HasKeysResponses[keyof HasKeysResponses];
+export type SaveKeysData = {
+    body: AppKeyView;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/SaveKeys';
+};
+export type SaveKeysErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type SaveKeysResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type SaveKeysResponse = SaveKeysResponses[keyof SaveKeysResponses];
+export type GetPublisherData = {
+    body?: never;
+    path?: never;
+    query?: {
+        server?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetPublisher';
+};
+export type GetPublisherErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Not Found
+     */
+    404: unknown;
+};
+export type GetPublisherResponses = {
+    /**
+     * OK
+     */
+    200: USyncPublisherView;
+};
+export type GetPublisherResponse = GetPublisherResponses[keyof GetPublisherResponses];
+export type GetPublishersData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/GetPublishers';
+};
+export type GetPublishersErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetPublishersResponses = {
+    /**
+     * OK
+     */
+    200: Array<USyncPublisherView>;
+};
+export type GetPublishersResponse = GetPublishersResponses[keyof GetPublishersResponses];
+export type StartData = {
+    body: PublisherStartRequest;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/Start';
+};
+export type StartErrors = {
+    /**
+     * Bad Request
+     */
+    400: ProblemDetails;
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Forbidden
+     */
+    403: ProblemDetails;
+    /**
+     * Conflict
+     */
+    409: PipelineRunRejected;
+};
+export type StartError = StartErrors[keyof StartErrors];
+export type StartResponses = {
+    /**
+     * Accepted
+     */
+    202: PipelineRunStarted;
+};
+export type StartResponse = StartResponses[keyof StartResponses];
+export type GetSiteStatusData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/GetSiteStatus';
+};
+export type GetSiteStatusErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetSiteStatusResponses = {
+    /**
+     * OK
+     */
+    200: SiteSeedStatus;
+};
+export type GetSiteStatusResponse = GetSiteStatusResponses[keyof GetSiteStatusResponses];
+export type AddToAllServersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        server?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/AddToAllServers';
+};
+export type AddToAllServersErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type AddToAllServersResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type AddToAllServersResponse = AddToAllServersResponses[keyof AddToAllServersResponses];
+export type CheckServerData = {
+    body?: never;
+    path?: never;
+    query?: {
+        server?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/CheckServer';
+};
+export type CheckServerErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type CheckServerResponses = {
+    /**
+     * OK
+     */
+    200: USyncPublishServerStatus;
+};
+export type CheckServerResponse = CheckServerResponses[keyof CheckServerResponses];
+export type CheckServerSignalRData = {
+    body?: never;
+    path?: never;
+    query?: {
+        server?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/CheckServerSignalR';
+};
+export type CheckServerSignalRErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type CheckServerSignalRResponses = {
+    /**
+     * OK
+     */
+    200: USyncPublishServerStatus;
+};
+export type CheckServerSignalRResponse = CheckServerSignalRResponses[keyof CheckServerSignalRResponses];
+export type CheckServerUrlData = {
+    body?: never;
+    path?: never;
+    query?: {
+        url?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/CheckServerUrl';
+};
+export type CheckServerUrlErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type CheckServerUrlResponses = {
+    /**
+     * OK
+     */
+    200: USyncPublishServerStatus;
+};
+export type CheckServerUrlResponse = CheckServerUrlResponses[keyof CheckServerUrlResponses];
+export type CopyServerData = {
+    body: SyncPublishServerCopyView;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/CopyServer';
+};
+export type CopyServerErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type CopyServerResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type CopyServerResponse = CopyServerResponses[keyof CopyServerResponses];
+export type DeleteServerData = {
+    body?: never;
+    path?: never;
+    query?: {
+        key?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/DeleteServer';
+};
+export type DeleteServerErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type DeleteServerResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type DeleteServerResponse = DeleteServerResponses[keyof DeleteServerResponses];
+export type GetAllServersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        enabledOnly?: boolean;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetAllServers';
+};
+export type GetAllServersErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetAllServersResponses = {
+    /**
+     * OK
+     */
+    200: Array<SyncPublishServerView>;
+};
+export type GetAllServersResponse = GetAllServersResponses[keyof GetAllServersResponses];
+export type GetAvailableServersData = {
+    body: SyncPublishAvailableServerRequest;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/GetAvailableServers';
+};
+export type GetAvailableServersErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetAvailableServersResponses = {
+    /**
+     * OK
+     */
+    200: Array<SyncPublishServerView>;
+};
+export type GetAvailableServersResponse = GetAvailableServersResponses[keyof GetAvailableServersResponses];
+export type GetCurrentServerData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/GetCurrent';
+};
+export type GetCurrentServerErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetCurrentServerResponses = {
+    /**
+     * OK
+     */
+    200: null | SyncPublishServerView;
+};
+export type GetCurrentServerResponse = GetCurrentServerResponses[keyof GetCurrentServerResponses];
+export type GetServerData = {
+    body?: never;
+    path?: never;
+    query?: {
+        key?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetServer';
+};
+export type GetServerErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetServerResponses = {
+    /**
+     * OK
+     */
+    200: null | SyncPublishServerView;
+};
+export type GetServerResponse = GetServerResponses[keyof GetServerResponses];
+export type GetServerByUrlData = {
+    body?: never;
+    path?: never;
+    query?: {
+        url?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetServerByUrl';
+};
+export type GetServerByUrlErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetServerByUrlResponses = {
+    /**
+     * OK
+     */
+    200: null | SyncPublishServerView;
+};
+export type GetServerByUrlResponse = GetServerByUrlResponses[keyof GetServerByUrlResponses];
+export type GetServersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        action?: string;
+        enabledOnly?: boolean;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetServers';
+};
+export type GetServersErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetServersResponses = {
+    /**
+     * OK
+     */
+    200: Array<SyncPublishServerView>;
+};
+export type GetServersResponse = GetServersResponses[keyof GetServersResponses];
+export type SaveServerData = {
+    body: SyncPublishServerView;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/SaveServer';
+};
+export type SaveServerErrors = {
+    /**
+     * Bad Request
+     */
+    400: ProblemDetails;
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type SaveServerError = SaveServerErrors[keyof SaveServerErrors];
+export type SaveServerResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type SaveServerResponse = SaveServerResponses[keyof SaveServerResponses];
+export type SetServerOrderData = {
+    body: Array<string>;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/SetServerOrder';
+};
+export type SetServerOrderErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type SetServerOrderResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type SetServerOrderResponse = SetServerOrderResponses[keyof SetServerOrderResponses];
+export type GetAncestorsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        id?: string;
+    };
+    url: '/umbraco/usync/api/v1/tree/server/ServerAncestors';
+};
+export type GetAncestorsErrors = {
+    /**
+     * Bad Request
+     */
+    400: ProblemDetails;
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetAncestorsError = GetAncestorsErrors[keyof GetAncestorsErrors];
+export type GetAncestorsResponses = {
+    /**
+     * OK
+     */
+    200: Array<SyncServerItemResponseModel>;
+};
+export type GetAncestorsResponse = GetAncestorsResponses[keyof GetAncestorsResponses];
+export type GetChildrenData = {
+    body?: never;
+    path?: never;
+    query?: {
+        parent?: string;
+        skip?: number | string;
+        take?: number | string;
+    };
+    url: '/umbraco/usync/api/v1/tree/server/ServerChildren';
+};
+export type GetChildrenErrors = {
+    /**
+     * Bad Request
+     */
+    400: ProblemDetails;
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetChildrenError = GetChildrenErrors[keyof GetChildrenErrors];
+export type GetChildrenResponses = {
+    /**
+     * OK
+     */
+    200: PagedSyncServerItemResponseModel;
+};
+export type GetChildrenResponse = GetChildrenResponses[keyof GetChildrenResponses];
+export type RootData = {
+    body?: never;
+    path?: never;
+    query?: {
+        skip?: number | string;
+        take?: number | string;
+        foldersOnly?: boolean;
+    };
+    url: '/umbraco/usync/api/v1/tree/server/ServerRoot';
+};
+export type RootErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type RootResponses = {
+    /**
+     * OK
+     */
+    200: PagedSyncServerItemResponseModel;
+};
+export type RootResponse = RootResponses[keyof RootResponses];
+export type GetButtonsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/GetButtons';
+};
+export type GetButtonsErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetButtonsResponses = {
+    /**
+     * OK
+     */
+    200: Array<string>;
+};
+export type GetButtonsResponse = GetButtonsResponses[keyof GetButtonsResponses];
+export type GetDescendantCountData = {
+    body?: never;
+    path?: never;
+    query?: {
+        id?: number | string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetDescendantCount';
+};
+export type GetDescendantCountErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetDescendantCountResponses = {
+    /**
+     * OK
+     */
+    200: number | string;
+};
+export type GetDescendantCountResponse = GetDescendantCountResponses[keyof GetDescendantCountResponses];
+export type GetSettingsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/GetSettings';
+};
+export type GetSettingsErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetSettingsResponses = {
+    /**
+     * OK
+     */
+    200: USyncPublishSettingsView;
+};
+export type GetSettingsResponse = GetSettingsResponses[keyof GetSettingsResponses];
+export type GetUserGroupsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/GetUserGroups';
+};
+export type GetUserGroupsErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetUserGroupsResponses = {
+    /**
+     * OK
+     */
+    200: Array<UserGroupListModel>;
+};
+export type GetUserGroupsResponse = GetUserGroupsResponses[keyof GetUserGroupsResponses];
+export type ReloadSettingsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/ReloadSettings';
+};
+export type ReloadSettingsErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type ReloadSettingsResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type ReloadSettingsResponse = ReloadSettingsResponses[keyof ReloadSettingsResponses];
+export type SaveSettingsData = {
+    body: USyncPublishSettingsView;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/SaveSettings';
+};
+export type SaveSettingsErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type SaveSettingsResponses = {
+    /**
+     * OK
+     */
+    200: boolean;
+};
+export type SaveSettingsResponse = SaveSettingsResponses[keyof SaveSettingsResponses];
+export type SyncSettingsData = {
+    body: ServerSyncRequest;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/SyncSettings';
+};
+export type SyncSettingsErrors = {
+    /**
+     * Bad Request
+     */
+    400: ProblemDetails;
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type SyncSettingsError = SyncSettingsErrors[keyof SyncSettingsErrors];
+export type SyncSettingsResponses = {
+    /**
+     * OK
+     */
+    200: ServerSyncResult;
+};
+export type SyncSettingsResponse = SyncSettingsResponses[keyof SyncSettingsResponses];
+export type GetActionViewData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/GetActionViewModel';
+};
+export type GetActionViewErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Not Found
+     */
+    404: unknown;
+};
+export type GetActionViewResponses = {
+    /**
+     * OK
+     */
+    200: USyncActionView;
+};
+export type GetActionViewResponse = GetActionViewResponses[keyof GetActionViewResponses];
+export type GetServerByAliasData = {
+    body?: never;
+    path?: never;
+    query?: {
+        serverAlias?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetServerByAlias';
+};
+export type GetServerByAliasErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Not Found
+     */
+    404: unknown;
+};
+export type GetServerByAliasResponses = {
+    /**
+     * OK
+     */
+    200: SyncPublishServerView;
+};
+export type GetServerByAliasResponse = GetServerByAliasResponses[keyof GetServerByAliasResponses];
+export type GetStrategyByPublisherData = {
+    body?: never;
+    path?: never;
+    query?: {
+        publisherAlias?: string;
+        mode?: PublishMode;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetStrategyByPublisher';
+};
+export type GetStrategyByPublisherErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Not Found
+     */
+    404: unknown;
+};
+export type GetStrategyByPublisherResponses = {
+    /**
+     * OK
+     */
+    200: string;
+};
+export type GetStrategyByPublisherResponse = GetStrategyByPublisherResponses[keyof GetStrategyByPublisherResponses];
+export type GetStrategyByServerData = {
+    body?: never;
+    path?: never;
+    query?: {
+        server?: string;
+        mode?: PublishMode;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetStrategyByServer';
+};
+export type GetStrategyByServerErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * Not Found
+     */
+    404: unknown;
+};
+export type GetStrategyByServerResponses = {
+    /**
+     * OK
+     */
+    200: string;
+};
+export type GetStrategyByServerResponse = GetStrategyByServerResponses[keyof GetStrategyByServerResponses];
+export type GetSyncItemData = {
+    body?: never;
+    path?: never;
+    query?: {
+        entityType?: string;
+        id?: string;
+    };
+    url: '/umbraco/usync/api/v1/Publisher/GetSyncItem';
+};
+export type GetSyncItemErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetSyncItemResponses = {
+    /**
+     * OK
+     */
+    200: SyncEntity;
+};
+export type GetSyncItemResponse = GetSyncItemResponses[keyof GetSyncItemResponses];
+export type GetProcessingOptionsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/SyncObjects';
+};
+export type GetProcessingOptionsErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetProcessingOptionsResponses = {
+    /**
+     * OK
+     */
+    200: SyncPublisherObjects;
+};
+export type GetProcessingOptionsResponse = GetProcessingOptionsResponses[keyof GetProcessingOptionsResponses];
+export type GetSyncSendOptionsByModeData = {
+    body?: never;
+    path?: never;
+    query?: {
+        serverAlias?: string;
+        mode?: PublishMode;
+        entityType?: string;
+    };
+    url: '/umbraco/usync/api/v2/Publisher/GetSyncSendOptions';
+};
+export type GetSyncSendOptionsByModeErrors = {
+    /**
+     * Bad Request
+     */
+    400: BadRequest;
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetSyncSendOptionsByModeError = GetSyncSendOptionsByModeErrors[keyof GetSyncSendOptionsByModeErrors];
+export type GetSyncSendOptionsByModeResponses = {
+    /**
+     * OK
+     */
+    200: SyncSendOptions;
+};
+export type GetSyncSendOptionsByModeResponse = GetSyncSendOptionsByModeResponses[keyof GetSyncSendOptionsByModeResponses];
+export type GetTemplatesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/umbraco/usync/api/v1/Publisher/GetTemplates';
+};
+export type GetTemplatesErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+};
+export type GetTemplatesResponses = {
+    /**
+     * OK
+     */
+    200: Array<SyncServerTemplateModel>;
+};
+export type GetTemplatesResponse = GetTemplatesResponses[keyof GetTemplatesResponses];