fizzy-sdk 0.2.4

// Generated by fizzy-sdk-generator from openapi.json and behavior-model.json. DO NOT EDIT.

use crate::http::Method;
use crate::route::{Pagination, ParamKind, ParamRole, Retry, Route, RouteParam};

/// `ActivateWebhook` — `POST /{accountId}/boards/{boardId}/webhooks/{webhookId}/activation.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503. Idempotent, so a resend is safe.
pub static ACTIVATE_WEBHOOK: Route = Route {
    id: "ActivateWebhook",
    service: "Webhooks",
    method: Method::POST,
    path: "/{accountId}/boards/{boardId}/webhooks/{webhookId}/activation.json",
    pattern: "/{accountId}/boards/{boardId}/webhooks/{webhookId}/activation",
    account_scoped: true,
    resource_type: "webhook",
    params: &[
        RouteParam {
            name: "boardId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
        RouteParam {
            name: "webhookId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `AssignCard` — `POST /{accountId}/cards/{cardNumber}/assignments.json`.
///
/// Sent once and never resent.
pub static ASSIGN_CARD: Route = Route {
    id: "AssignCard",
    service: "Cards",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/assignments.json",
    pattern: "/{accountId}/cards/{cardNumber}/assignments",
    account_scoped: true,
    resource_type: "assignment",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `BulkReadNotifications` — `POST /{accountId}/notifications/bulk_reading.json`.
///
/// Sent once and never resent.
pub static BULK_READ_NOTIFICATIONS: Route = Route {
    id: "BulkReadNotifications",
    service: "Notifications",
    method: Method::POST,
    path: "/{accountId}/notifications/bulk_reading.json",
    pattern: "/{accountId}/notifications/bulk_reading",
    account_scoped: true,
    resource_type: "notification",
    params: &[],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CloseCard` — `POST /{accountId}/cards/{cardNumber}/closure.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503. Idempotent, so a resend is safe.
pub static CLOSE_CARD: Route = Route {
    id: "CloseCard",
    service: "Cards",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/closure.json",
    pattern: "/{accountId}/cards/{cardNumber}/closure",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `CompleteJoin` — `POST /users/joins.json`.
///
/// Sent once and never resent.
pub static COMPLETE_JOIN: Route = Route {
    id: "CompleteJoin",
    service: "Sessions",
    method: Method::POST,
    path: "/users/joins.json",
    pattern: "/users/joins",
    account_scoped: false,
    resource_type: "join",
    params: &[],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CompleteSignup` — `POST /signup/completion.json`.
///
/// Sent once and never resent.
pub static COMPLETE_SIGNUP: Route = Route {
    id: "CompleteSignup",
    service: "Sessions",
    method: Method::POST,
    path: "/signup/completion.json",
    pattern: "/signup/completion",
    account_scoped: false,
    resource_type: "signup",
    params: &[],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `ConfirmEmailAddressChange` — `POST /{accountId}/users/{userId}/email_addresses/{emailAddressToken}/confirmation.json`.
///
/// Sent once and never resent.
pub static CONFIRM_EMAIL_ADDRESS_CHANGE: Route = Route {
    id: "ConfirmEmailAddressChange",
    service: "Users",
    method: Method::POST,
    path: "/{accountId}/users/{userId}/email_addresses/{emailAddressToken}/confirmation.json",
    pattern: "/{accountId}/users/{userId}/email_addresses/{emailAddressToken}/confirmation",
    account_scoped: true,
    resource_type: "email_address",
    params: &[
        RouteParam {
            name: "userId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
        RouteParam {
            name: "emailAddressToken",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
    ],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreateAccessToken` — `POST /my/access_tokens.json`.
///
/// Sent once and never resent.
pub static CREATE_ACCESS_TOKEN: Route = Route {
    id: "CreateAccessToken",
    service: "AccessTokens",
    method: Method::POST,
    path: "/my/access_tokens.json",
    pattern: "/my/access_tokens",
    account_scoped: false,
    resource_type: "access_token",
    params: &[],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreateAccountExport` — `POST /{accountId}/account/exports.json`.
///
/// Sent once and never resent.
pub static CREATE_ACCOUNT_EXPORT: Route = Route {
    id: "CreateAccountExport",
    service: "Account",
    method: Method::POST,
    path: "/{accountId}/account/exports.json",
    pattern: "/{accountId}/account/exports",
    account_scoped: true,
    resource_type: "account_export",
    params: &[],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreateBoard` — `POST /{accountId}/boards.json`.
///
/// Sent once and never resent.
pub static CREATE_BOARD: Route = Route {
    id: "CreateBoard",
    service: "Boards",
    method: Method::POST,
    path: "/{accountId}/boards.json",
    pattern: "/{accountId}/boards",
    account_scoped: true,
    resource_type: "board",
    params: &[],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreateCard` — `POST /{accountId}/cards.json`.
///
/// Sent once and never resent.
pub static CREATE_CARD: Route = Route {
    id: "CreateCard",
    service: "Cards",
    method: Method::POST,
    path: "/{accountId}/cards.json",
    pattern: "/{accountId}/cards",
    account_scoped: true,
    resource_type: "card",
    params: &[],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreateCardReaction` — `POST /{accountId}/cards/{cardNumber}/reactions.json`.
///
/// Sent once and never resent.
pub static CREATE_CARD_REACTION: Route = Route {
    id: "CreateCardReaction",
    service: "Reactions",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/reactions.json",
    pattern: "/{accountId}/cards/{cardNumber}/reactions",
    account_scoped: true,
    resource_type: "reaction",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreateColumn` — `POST /{accountId}/boards/{boardId}/columns.json`.
///
/// Sent once and never resent.
pub static CREATE_COLUMN: Route = Route {
    id: "CreateColumn",
    service: "Columns",
    method: Method::POST,
    path: "/{accountId}/boards/{boardId}/columns.json",
    pattern: "/{accountId}/boards/{boardId}/columns",
    account_scoped: true,
    resource_type: "column",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreateComment` — `POST /{accountId}/cards/{cardNumber}/comments.json`.
///
/// Sent once and never resent.
pub static CREATE_COMMENT: Route = Route {
    id: "CreateComment",
    service: "Comments",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/comments.json",
    pattern: "/{accountId}/cards/{cardNumber}/comments",
    account_scoped: true,
    resource_type: "comment",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreateCommentReaction` — `POST /{accountId}/cards/{cardNumber}/comments/{commentId}/reactions.json`.
///
/// Sent once and never resent.
pub static CREATE_COMMENT_REACTION: Route = Route {
    id: "CreateCommentReaction",
    service: "Reactions",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/comments/{commentId}/reactions.json",
    pattern: "/{accountId}/cards/{cardNumber}/comments/{commentId}/reactions",
    account_scoped: true,
    resource_type: "reaction",
    params: &[
        RouteParam {
            name: "cardNumber",
            role: ParamRole::Parent,
            kind: ParamKind::Int32,
        },
        RouteParam {
            name: "commentId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
    ],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreateDirectUpload` — `POST /{accountId}/rails/active_storage/direct_uploads`.
///
/// Sent once and never resent.
pub static CREATE_DIRECT_UPLOAD: Route = Route {
    id: "CreateDirectUpload",
    service: "Uploads",
    method: Method::POST,
    path: "/{accountId}/rails/active_storage/direct_uploads",
    pattern: "/{accountId}/rails/active_storage/direct_uploads",
    account_scoped: true,
    resource_type: "direct_upload",
    params: &[],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreatePushSubscription` — `POST /{accountId}/users/{userId}/push_subscriptions.json`.
///
/// Sent once and never resent.
pub static CREATE_PUSH_SUBSCRIPTION: Route = Route {
    id: "CreatePushSubscription",
    service: "Users",
    method: Method::POST,
    path: "/{accountId}/users/{userId}/push_subscriptions.json",
    pattern: "/{accountId}/users/{userId}/push_subscriptions",
    account_scoped: true,
    resource_type: "push_subscription",
    params: &[RouteParam {
        name: "userId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreateSession` — `POST /session.json`.
///
/// Sent once and never resent.
pub static CREATE_SESSION: Route = Route {
    id: "CreateSession",
    service: "Sessions",
    method: Method::POST,
    path: "/session.json",
    pattern: "/session",
    account_scoped: false,
    resource_type: "session",
    params: &[],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreateStep` — `POST /{accountId}/cards/{cardNumber}/steps.json`.
///
/// Sent once and never resent.
pub static CREATE_STEP: Route = Route {
    id: "CreateStep",
    service: "Steps",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/steps.json",
    pattern: "/{accountId}/cards/{cardNumber}/steps",
    account_scoped: true,
    resource_type: "step",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreateUserDataExport` — `POST /{accountId}/users/{userId}/data_exports.json`.
///
/// Sent once and never resent.
pub static CREATE_USER_DATA_EXPORT: Route = Route {
    id: "CreateUserDataExport",
    service: "Users",
    method: Method::POST,
    path: "/{accountId}/users/{userId}/data_exports.json",
    pattern: "/{accountId}/users/{userId}/data_exports",
    account_scoped: true,
    resource_type: "data_export",
    params: &[RouteParam {
        name: "userId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `CreateWebhook` — `POST /{accountId}/boards/{boardId}/webhooks.json`.
///
/// Sent once and never resent.
pub static CREATE_WEBHOOK: Route = Route {
    id: "CreateWebhook",
    service: "Webhooks",
    method: Method::POST,
    path: "/{accountId}/boards/{boardId}/webhooks.json",
    pattern: "/{accountId}/boards/{boardId}/webhooks",
    account_scoped: true,
    resource_type: "webhook",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `DeactivateUser` — `DELETE /{accountId}/users/{userId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static DEACTIVATE_USER: Route = Route {
    id: "DeactivateUser",
    service: "Users",
    method: Method::DELETE,
    path: "/{accountId}/users/{userId}",
    pattern: "/{accountId}/users/{userId}",
    account_scoped: true,
    resource_type: "user",
    params: &[RouteParam {
        name: "userId",
        role: ParamRole::Recording,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `DeleteAccessToken` — `DELETE /my/access_tokens/{accessTokenId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static DELETE_ACCESS_TOKEN: Route = Route {
    id: "DeleteAccessToken",
    service: "AccessTokens",
    method: Method::DELETE,
    path: "/my/access_tokens/{accessTokenId}",
    pattern: "/my/access_tokens/{accessTokenId}",
    account_scoped: false,
    resource_type: "access_token",
    params: &[RouteParam {
        name: "accessTokenId",
        role: ParamRole::Recording,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `DeleteBoard` — `DELETE /{accountId}/boards/{boardId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static DELETE_BOARD: Route = Route {
    id: "DeleteBoard",
    service: "Boards",
    method: Method::DELETE,
    path: "/{accountId}/boards/{boardId}",
    pattern: "/{accountId}/boards/{boardId}",
    account_scoped: true,
    resource_type: "board",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Recording,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `DeleteCard` — `DELETE /{accountId}/cards/{cardNumber}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static DELETE_CARD: Route = Route {
    id: "DeleteCard",
    service: "Cards",
    method: Method::DELETE,
    path: "/{accountId}/cards/{cardNumber}",
    pattern: "/{accountId}/cards/{cardNumber}",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Recording,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `DeleteCardImage` — `DELETE /{accountId}/cards/{cardNumber}/image.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static DELETE_CARD_IMAGE: Route = Route {
    id: "DeleteCardImage",
    service: "Cards",
    method: Method::DELETE,
    path: "/{accountId}/cards/{cardNumber}/image.json",
    pattern: "/{accountId}/cards/{cardNumber}/image",
    account_scoped: true,
    resource_type: "card_image",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `DeleteCardReaction` — `DELETE /{accountId}/cards/{cardNumber}/reactions/{reactionId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static DELETE_CARD_REACTION: Route = Route {
    id: "DeleteCardReaction",
    service: "Reactions",
    method: Method::DELETE,
    path: "/{accountId}/cards/{cardNumber}/reactions/{reactionId}",
    pattern: "/{accountId}/cards/{cardNumber}/reactions/{reactionId}",
    account_scoped: true,
    resource_type: "reaction",
    params: &[
        RouteParam {
            name: "cardNumber",
            role: ParamRole::Parent,
            kind: ParamKind::Int32,
        },
        RouteParam {
            name: "reactionId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `DeleteColumn` — `DELETE /{accountId}/boards/{boardId}/columns/{columnId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static DELETE_COLUMN: Route = Route {
    id: "DeleteColumn",
    service: "Columns",
    method: Method::DELETE,
    path: "/{accountId}/boards/{boardId}/columns/{columnId}",
    pattern: "/{accountId}/boards/{boardId}/columns/{columnId}",
    account_scoped: true,
    resource_type: "column",
    params: &[
        RouteParam {
            name: "boardId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
        RouteParam {
            name: "columnId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `DeleteComment` — `DELETE /{accountId}/cards/{cardNumber}/comments/{commentId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static DELETE_COMMENT: Route = Route {
    id: "DeleteComment",
    service: "Comments",
    method: Method::DELETE,
    path: "/{accountId}/cards/{cardNumber}/comments/{commentId}",
    pattern: "/{accountId}/cards/{cardNumber}/comments/{commentId}",
    account_scoped: true,
    resource_type: "comment",
    params: &[
        RouteParam {
            name: "cardNumber",
            role: ParamRole::Parent,
            kind: ParamKind::Int32,
        },
        RouteParam {
            name: "commentId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `DeleteCommentReaction` — `DELETE /{accountId}/cards/{cardNumber}/comments/{commentId}/reactions/{reactionId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static DELETE_COMMENT_REACTION: Route = Route {
    id: "DeleteCommentReaction",
    service: "Reactions",
    method: Method::DELETE,
    path: "/{accountId}/cards/{cardNumber}/comments/{commentId}/reactions/{reactionId}",
    pattern: "/{accountId}/cards/{cardNumber}/comments/{commentId}/reactions/{reactionId}",
    account_scoped: true,
    resource_type: "reaction",
    params: &[
        RouteParam {
            name: "cardNumber",
            role: ParamRole::Parent,
            kind: ParamKind::Int32,
        },
        RouteParam {
            name: "commentId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
        RouteParam {
            name: "reactionId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `DeletePushSubscription` — `DELETE /{accountId}/users/{userId}/push_subscriptions/{pushSubscriptionId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static DELETE_PUSH_SUBSCRIPTION: Route = Route {
    id: "DeletePushSubscription",
    service: "Users",
    method: Method::DELETE,
    path: "/{accountId}/users/{userId}/push_subscriptions/{pushSubscriptionId}",
    pattern: "/{accountId}/users/{userId}/push_subscriptions/{pushSubscriptionId}",
    account_scoped: true,
    resource_type: "push_subscription",
    params: &[
        RouteParam {
            name: "userId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
        RouteParam {
            name: "pushSubscriptionId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `DeleteStep` — `DELETE /{accountId}/cards/{cardNumber}/steps/{stepId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static DELETE_STEP: Route = Route {
    id: "DeleteStep",
    service: "Steps",
    method: Method::DELETE,
    path: "/{accountId}/cards/{cardNumber}/steps/{stepId}",
    pattern: "/{accountId}/cards/{cardNumber}/steps/{stepId}",
    account_scoped: true,
    resource_type: "step",
    params: &[
        RouteParam {
            name: "cardNumber",
            role: ParamRole::Parent,
            kind: ParamKind::Int32,
        },
        RouteParam {
            name: "stepId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `DeleteUserAvatar` — `DELETE /{accountId}/users/{userId}/avatar`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static DELETE_USER_AVATAR: Route = Route {
    id: "DeleteUserAvatar",
    service: "Users",
    method: Method::DELETE,
    path: "/{accountId}/users/{userId}/avatar",
    pattern: "/{accountId}/users/{userId}/avatar",
    account_scoped: true,
    resource_type: "avatar",
    params: &[RouteParam {
        name: "userId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `DeleteWebhook` — `DELETE /{accountId}/boards/{boardId}/webhooks/{webhookId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static DELETE_WEBHOOK: Route = Route {
    id: "DeleteWebhook",
    service: "Webhooks",
    method: Method::DELETE,
    path: "/{accountId}/boards/{boardId}/webhooks/{webhookId}",
    pattern: "/{accountId}/boards/{boardId}/webhooks/{webhookId}",
    account_scoped: true,
    resource_type: "webhook",
    params: &[
        RouteParam {
            name: "boardId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
        RouteParam {
            name: "webhookId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `DestroySession` — `DELETE /session.json`.
///
/// Sent once and never resent.
pub static DESTROY_SESSION: Route = Route {
    id: "DestroySession",
    service: "Sessions",
    method: Method::DELETE,
    path: "/session.json",
    pattern: "/session",
    account_scoped: false,
    resource_type: "session",
    params: &[],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `GetAccountExport` — `GET /{accountId}/account/exports/{exportId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_ACCOUNT_EXPORT: Route = Route {
    id: "GetAccountExport",
    service: "Account",
    method: Method::GET,
    path: "/{accountId}/account/exports/{exportId}",
    pattern: "/{accountId}/account/exports/{exportId}",
    account_scoped: true,
    resource_type: "account_export",
    params: &[RouteParam {
        name: "exportId",
        role: ParamRole::Recording,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GetAccountSettings` — `GET /{accountId}/account/settings.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_ACCOUNT_SETTINGS: Route = Route {
    id: "GetAccountSettings",
    service: "Account",
    method: Method::GET,
    path: "/{accountId}/account/settings.json",
    pattern: "/{accountId}/account/settings",
    account_scoped: true,
    resource_type: "account_settings",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GetBoard` — `GET /{accountId}/boards/{boardId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_BOARD: Route = Route {
    id: "GetBoard",
    service: "Boards",
    method: Method::GET,
    path: "/{accountId}/boards/{boardId}",
    pattern: "/{accountId}/boards/{boardId}",
    account_scoped: true,
    resource_type: "board",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Recording,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GetCard` — `GET /{accountId}/cards/{cardNumber}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_CARD: Route = Route {
    id: "GetCard",
    service: "Cards",
    method: Method::GET,
    path: "/{accountId}/cards/{cardNumber}",
    pattern: "/{accountId}/cards/{cardNumber}",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Recording,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GetColumn` — `GET /{accountId}/boards/{boardId}/columns/{columnId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_COLUMN: Route = Route {
    id: "GetColumn",
    service: "Columns",
    method: Method::GET,
    path: "/{accountId}/boards/{boardId}/columns/{columnId}",
    pattern: "/{accountId}/boards/{boardId}/columns/{columnId}",
    account_scoped: true,
    resource_type: "column",
    params: &[
        RouteParam {
            name: "boardId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
        RouteParam {
            name: "columnId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GetComment` — `GET /{accountId}/cards/{cardNumber}/comments/{commentId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_COMMENT: Route = Route {
    id: "GetComment",
    service: "Comments",
    method: Method::GET,
    path: "/{accountId}/cards/{cardNumber}/comments/{commentId}",
    pattern: "/{accountId}/cards/{cardNumber}/comments/{commentId}",
    account_scoped: true,
    resource_type: "comment",
    params: &[
        RouteParam {
            name: "cardNumber",
            role: ParamRole::Parent,
            kind: ParamKind::Int32,
        },
        RouteParam {
            name: "commentId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GetJoinCode` — `GET /{accountId}/account/join_code.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_JOIN_CODE: Route = Route {
    id: "GetJoinCode",
    service: "Account",
    method: Method::GET,
    path: "/{accountId}/account/join_code.json",
    pattern: "/{accountId}/account/join_code",
    account_scoped: true,
    resource_type: "join_code",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GetMyIdentity` — `GET /my/identity.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_MY_IDENTITY: Route = Route {
    id: "GetMyIdentity",
    service: "Identity",
    method: Method::GET,
    path: "/my/identity.json",
    pattern: "/my/identity",
    account_scoped: false,
    resource_type: "identity",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GetNotificationSettings` — `GET /{accountId}/notifications/settings.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_NOTIFICATION_SETTINGS: Route = Route {
    id: "GetNotificationSettings",
    service: "Notifications",
    method: Method::GET,
    path: "/{accountId}/notifications/settings.json",
    pattern: "/{accountId}/notifications/settings",
    account_scoped: true,
    resource_type: "notification_settings",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GetNotificationTray` — `GET /{accountId}/notifications/tray.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_NOTIFICATION_TRAY: Route = Route {
    id: "GetNotificationTray",
    service: "Notifications",
    method: Method::GET,
    path: "/{accountId}/notifications/tray.json",
    pattern: "/{accountId}/notifications/tray",
    account_scoped: true,
    resource_type: "notification",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GetStep` — `GET /{accountId}/cards/{cardNumber}/steps/{stepId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_STEP: Route = Route {
    id: "GetStep",
    service: "Steps",
    method: Method::GET,
    path: "/{accountId}/cards/{cardNumber}/steps/{stepId}",
    pattern: "/{accountId}/cards/{cardNumber}/steps/{stepId}",
    account_scoped: true,
    resource_type: "step",
    params: &[
        RouteParam {
            name: "cardNumber",
            role: ParamRole::Parent,
            kind: ParamKind::Int32,
        },
        RouteParam {
            name: "stepId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GetUser` — `GET /{accountId}/users/{userId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_USER: Route = Route {
    id: "GetUser",
    service: "Users",
    method: Method::GET,
    path: "/{accountId}/users/{userId}",
    pattern: "/{accountId}/users/{userId}",
    account_scoped: true,
    resource_type: "user",
    params: &[RouteParam {
        name: "userId",
        role: ParamRole::Recording,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GetUserDataExport` — `GET /{accountId}/users/{userId}/data_exports/{exportId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_USER_DATA_EXPORT: Route = Route {
    id: "GetUserDataExport",
    service: "Users",
    method: Method::GET,
    path: "/{accountId}/users/{userId}/data_exports/{exportId}",
    pattern: "/{accountId}/users/{userId}/data_exports/{exportId}",
    account_scoped: true,
    resource_type: "data_export",
    params: &[
        RouteParam {
            name: "userId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
        RouteParam {
            name: "exportId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GetWebhook` — `GET /{accountId}/boards/{boardId}/webhooks/{webhookId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static GET_WEBHOOK: Route = Route {
    id: "GetWebhook",
    service: "Webhooks",
    method: Method::GET,
    path: "/{accountId}/boards/{boardId}/webhooks/{webhookId}",
    pattern: "/{accountId}/boards/{boardId}/webhooks/{webhookId}",
    account_scoped: true,
    resource_type: "webhook",
    params: &[
        RouteParam {
            name: "boardId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
        RouteParam {
            name: "webhookId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `GoldCard` — `POST /{accountId}/cards/{cardNumber}/goldness.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503. Idempotent, so a resend is safe.
pub static GOLD_CARD: Route = Route {
    id: "GoldCard",
    service: "Cards",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/goldness.json",
    pattern: "/{accountId}/cards/{cardNumber}/goldness",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListAccessTokens` — `GET /my/access_tokens.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static LIST_ACCESS_TOKENS: Route = Route {
    id: "ListAccessTokens",
    service: "AccessTokens",
    method: Method::GET,
    path: "/my/access_tokens.json",
    pattern: "/my/access_tokens",
    account_scoped: false,
    resource_type: "access_token",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListActivities` — `GET /{accountId}/activities.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
///
/// Paginated: the answer is a page with `page` as its cursor, and the next one is read with `next_page`.
pub static LIST_ACTIVITIES: Route = Route {
    id: "ListActivities",
    service: "Cards",
    method: Method::GET,
    path: "/{accountId}/activities.json",
    pattern: "/{accountId}/activities",
    account_scoped: true,
    resource_type: "activity",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::Link { page_param: "page" },
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListBoardAccesses` — `GET /{accountId}/boards/{boardId}/accesses.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static LIST_BOARD_ACCESSES: Route = Route {
    id: "ListBoardAccesses",
    service: "Boards",
    method: Method::GET,
    path: "/{accountId}/boards/{boardId}/accesses.json",
    pattern: "/{accountId}/boards/{boardId}/accesses",
    account_scoped: true,
    resource_type: "board_access",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListBoards` — `GET /{accountId}/boards.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
///
/// Paginated: the answer is a page with `page` as its cursor, and the next one is read with `next_page`.
pub static LIST_BOARDS: Route = Route {
    id: "ListBoards",
    service: "Boards",
    method: Method::GET,
    path: "/{accountId}/boards.json",
    pattern: "/{accountId}/boards",
    account_scoped: true,
    resource_type: "board",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::Link { page_param: "page" },
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListCardReactions` — `GET /{accountId}/cards/{cardNumber}/reactions.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static LIST_CARD_REACTIONS: Route = Route {
    id: "ListCardReactions",
    service: "Reactions",
    method: Method::GET,
    path: "/{accountId}/cards/{cardNumber}/reactions.json",
    pattern: "/{accountId}/cards/{cardNumber}/reactions",
    account_scoped: true,
    resource_type: "reaction",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListCards` — `GET /{accountId}/cards.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
///
/// Paginated: the answer is a page with `page` as its cursor, and the next one is read with `next_page`.
pub static LIST_CARDS: Route = Route {
    id: "ListCards",
    service: "Cards",
    method: Method::GET,
    path: "/{accountId}/cards.json",
    pattern: "/{accountId}/cards",
    account_scoped: true,
    resource_type: "card",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::Link { page_param: "page" },
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListClosedCards` — `GET /{accountId}/boards/{boardId}/columns/closed.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
///
/// Paginated: the answer is a page with `page` as its cursor, and the next one is read with `next_page`.
pub static LIST_CLOSED_CARDS: Route = Route {
    id: "ListClosedCards",
    service: "Boards",
    method: Method::GET,
    path: "/{accountId}/boards/{boardId}/columns/closed.json",
    pattern: "/{accountId}/boards/{boardId}/columns/closed",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: true,
    pagination: Pagination::Link { page_param: "page" },
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListColumnCards` — `GET /{accountId}/boards/{boardId}/columns/{columnId}/cards.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
///
/// Paginated: the answer is a page with `page` as its cursor, and the next one is read with `next_page`.
pub static LIST_COLUMN_CARDS: Route = Route {
    id: "ListColumnCards",
    service: "Cards",
    method: Method::GET,
    path: "/{accountId}/boards/{boardId}/columns/{columnId}/cards.json",
    pattern: "/{accountId}/boards/{boardId}/columns/{columnId}/cards",
    account_scoped: true,
    resource_type: "card",
    params: &[
        RouteParam {
            name: "boardId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
        RouteParam {
            name: "columnId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: true,
    pagination: Pagination::Link { page_param: "page" },
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListColumns` — `GET /{accountId}/boards/{boardId}/columns.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static LIST_COLUMNS: Route = Route {
    id: "ListColumns",
    service: "Columns",
    method: Method::GET,
    path: "/{accountId}/boards/{boardId}/columns.json",
    pattern: "/{accountId}/boards/{boardId}/columns",
    account_scoped: true,
    resource_type: "column",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListCommentReactions` — `GET /{accountId}/cards/{cardNumber}/comments/{commentId}/reactions.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static LIST_COMMENT_REACTIONS: Route = Route {
    id: "ListCommentReactions",
    service: "Reactions",
    method: Method::GET,
    path: "/{accountId}/cards/{cardNumber}/comments/{commentId}/reactions.json",
    pattern: "/{accountId}/cards/{cardNumber}/comments/{commentId}/reactions",
    account_scoped: true,
    resource_type: "reaction",
    params: &[
        RouteParam {
            name: "cardNumber",
            role: ParamRole::Parent,
            kind: ParamKind::Int32,
        },
        RouteParam {
            name: "commentId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListComments` — `GET /{accountId}/cards/{cardNumber}/comments.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
///
/// Paginated: the answer is a page with `page` as its cursor, and the next one is read with `next_page`.
pub static LIST_COMMENTS: Route = Route {
    id: "ListComments",
    service: "Comments",
    method: Method::GET,
    path: "/{accountId}/cards/{cardNumber}/comments.json",
    pattern: "/{accountId}/cards/{cardNumber}/comments",
    account_scoped: true,
    resource_type: "comment",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: true,
    pagination: Pagination::Link { page_param: "page" },
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListNotifications` — `GET /{accountId}/notifications.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
///
/// Paginated: the answer is a page with `page` as its cursor, and the next one is read with `next_page`.
pub static LIST_NOTIFICATIONS: Route = Route {
    id: "ListNotifications",
    service: "Notifications",
    method: Method::GET,
    path: "/{accountId}/notifications.json",
    pattern: "/{accountId}/notifications",
    account_scoped: true,
    resource_type: "notification",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::Link { page_param: "page" },
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListPins` — `GET /{accountId}/my/pins.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static LIST_PINS: Route = Route {
    id: "ListPins",
    service: "Pins",
    method: Method::GET,
    path: "/{accountId}/my/pins.json",
    pattern: "/{accountId}/my/pins",
    account_scoped: true,
    resource_type: "card",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListPostponedCards` — `GET /{accountId}/boards/{boardId}/columns/not_now.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
///
/// Paginated: the answer is a page with `page` as its cursor, and the next one is read with `next_page`.
pub static LIST_POSTPONED_CARDS: Route = Route {
    id: "ListPostponedCards",
    service: "Boards",
    method: Method::GET,
    path: "/{accountId}/boards/{boardId}/columns/not_now.json",
    pattern: "/{accountId}/boards/{boardId}/columns/not_now",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: true,
    pagination: Pagination::Link { page_param: "page" },
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListSteps` — `GET /{accountId}/cards/{cardNumber}/steps.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static LIST_STEPS: Route = Route {
    id: "ListSteps",
    service: "Steps",
    method: Method::GET,
    path: "/{accountId}/cards/{cardNumber}/steps.json",
    pattern: "/{accountId}/cards/{cardNumber}/steps",
    account_scoped: true,
    resource_type: "step",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListStreamCards` — `GET /{accountId}/boards/{boardId}/columns/stream.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
///
/// Paginated: the answer is a page with `page` as its cursor, and the next one is read with `next_page`.
pub static LIST_STREAM_CARDS: Route = Route {
    id: "ListStreamCards",
    service: "Boards",
    method: Method::GET,
    path: "/{accountId}/boards/{boardId}/columns/stream.json",
    pattern: "/{accountId}/boards/{boardId}/columns/stream",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: true,
    pagination: Pagination::Link { page_param: "page" },
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListTags` — `GET /{accountId}/tags.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
///
/// Paginated: the answer is a page with `page` as its cursor, and the next one is read with `next_page`.
pub static LIST_TAGS: Route = Route {
    id: "ListTags",
    service: "Tags",
    method: Method::GET,
    path: "/{accountId}/tags.json",
    pattern: "/{accountId}/tags",
    account_scoped: true,
    resource_type: "tag",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::Link { page_param: "page" },
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListUsers` — `GET /{accountId}/users.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
///
/// Paginated: the answer is a page with `page` as its cursor, and the next one is read with `next_page`.
pub static LIST_USERS: Route = Route {
    id: "ListUsers",
    service: "Users",
    method: Method::GET,
    path: "/{accountId}/users.json",
    pattern: "/{accountId}/users",
    account_scoped: true,
    resource_type: "user",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::Link { page_param: "page" },
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListWebhookDeliveries` — `GET /{accountId}/boards/{boardId}/webhooks/{webhookId}/deliveries.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
///
/// Paginated: the answer is a page with `page` as its cursor, and the next one is read with `next_page`.
pub static LIST_WEBHOOK_DELIVERIES: Route = Route {
    id: "ListWebhookDeliveries",
    service: "Webhooks",
    method: Method::GET,
    path: "/{accountId}/boards/{boardId}/webhooks/{webhookId}/deliveries.json",
    pattern: "/{accountId}/boards/{boardId}/webhooks/{webhookId}/deliveries",
    account_scoped: true,
    resource_type: "webhook_delivery",
    params: &[
        RouteParam {
            name: "boardId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
        RouteParam {
            name: "webhookId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: true,
    pagination: Pagination::Link { page_param: "page" },
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `ListWebhooks` — `GET /{accountId}/boards/{boardId}/webhooks.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static LIST_WEBHOOKS: Route = Route {
    id: "ListWebhooks",
    service: "Webhooks",
    method: Method::GET,
    path: "/{accountId}/boards/{boardId}/webhooks.json",
    pattern: "/{accountId}/boards/{boardId}/webhooks",
    account_scoped: true,
    resource_type: "webhook",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: true,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `MarkCardRead` — `POST /{accountId}/cards/{cardNumber}/reading.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503. Idempotent, so a resend is safe.
pub static MARK_CARD_READ: Route = Route {
    id: "MarkCardRead",
    service: "Cards",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/reading.json",
    pattern: "/{accountId}/cards/{cardNumber}/reading",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `MarkCardUnread` — `DELETE /{accountId}/cards/{cardNumber}/reading.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static MARK_CARD_UNREAD: Route = Route {
    id: "MarkCardUnread",
    service: "Cards",
    method: Method::DELETE,
    path: "/{accountId}/cards/{cardNumber}/reading.json",
    pattern: "/{accountId}/cards/{cardNumber}/reading",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `MoveCard` — `PATCH /{accountId}/cards/{cardNumber}/board.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static MOVE_CARD: Route = Route {
    id: "MoveCard",
    service: "Cards",
    method: Method::PATCH,
    path: "/{accountId}/cards/{cardNumber}/board.json",
    pattern: "/{accountId}/cards/{cardNumber}/board",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `MoveColumnLeft` — `POST /{accountId}/columns/{columnId}/left_position.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503. Idempotent, so a resend is safe.
pub static MOVE_COLUMN_LEFT: Route = Route {
    id: "MoveColumnLeft",
    service: "Columns",
    method: Method::POST,
    path: "/{accountId}/columns/{columnId}/left_position.json",
    pattern: "/{accountId}/columns/{columnId}/left_position",
    account_scoped: true,
    resource_type: "column",
    params: &[RouteParam {
        name: "columnId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `MoveColumnRight` — `POST /{accountId}/columns/{columnId}/right_position.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503. Idempotent, so a resend is safe.
pub static MOVE_COLUMN_RIGHT: Route = Route {
    id: "MoveColumnRight",
    service: "Columns",
    method: Method::POST,
    path: "/{accountId}/columns/{columnId}/right_position.json",
    pattern: "/{accountId}/columns/{columnId}/right_position",
    account_scoped: true,
    resource_type: "column",
    params: &[RouteParam {
        name: "columnId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `PinCard` — `POST /{accountId}/cards/{cardNumber}/pin.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503. Idempotent, so a resend is safe.
pub static PIN_CARD: Route = Route {
    id: "PinCard",
    service: "Cards",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/pin.json",
    pattern: "/{accountId}/cards/{cardNumber}/pin",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `PostponeCard` — `POST /{accountId}/cards/{cardNumber}/not_now.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503. Idempotent, so a resend is safe.
pub static POSTPONE_CARD: Route = Route {
    id: "PostponeCard",
    service: "Cards",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/not_now.json",
    pattern: "/{accountId}/cards/{cardNumber}/not_now",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `PublishBoard` — `POST /{accountId}/boards/{boardId}/publication.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503. Idempotent, so a resend is safe.
pub static PUBLISH_BOARD: Route = Route {
    id: "PublishBoard",
    service: "Boards",
    method: Method::POST,
    path: "/{accountId}/boards/{boardId}/publication.json",
    pattern: "/{accountId}/boards/{boardId}/publication",
    account_scoped: true,
    resource_type: "board",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `PublishCard` — `POST /{accountId}/cards/{cardNumber}/publish.json`.
///
/// Sent once and never resent.
pub static PUBLISH_CARD: Route = Route {
    id: "PublishCard",
    service: "Cards",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/publish.json",
    pattern: "/{accountId}/cards/{cardNumber}/publish",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `ReadNotification` — `POST /{accountId}/notifications/{notificationId}/reading.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503. Idempotent, so a resend is safe.
pub static READ_NOTIFICATION: Route = Route {
    id: "ReadNotification",
    service: "Notifications",
    method: Method::POST,
    path: "/{accountId}/notifications/{notificationId}/reading.json",
    pattern: "/{accountId}/notifications/{notificationId}/reading",
    account_scoped: true,
    resource_type: "notification",
    params: &[RouteParam {
        name: "notificationId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `RedeemMagicLink` — `POST /session/magic_link.json`.
///
/// Sent once and never resent.
pub static REDEEM_MAGIC_LINK: Route = Route {
    id: "RedeemMagicLink",
    service: "Sessions",
    method: Method::POST,
    path: "/session/magic_link.json",
    pattern: "/session/magic_link",
    account_scoped: false,
    resource_type: "session",
    params: &[],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `RegisterDevice` — `POST /{accountId}/devices`.
///
/// Sent once and never resent.
pub static REGISTER_DEVICE: Route = Route {
    id: "RegisterDevice",
    service: "Devices",
    method: Method::POST,
    path: "/{accountId}/devices",
    pattern: "/{accountId}/devices",
    account_scoped: true,
    resource_type: "device",
    params: &[],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `ReopenCard` — `DELETE /{accountId}/cards/{cardNumber}/closure.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static REOPEN_CARD: Route = Route {
    id: "ReopenCard",
    service: "Cards",
    method: Method::DELETE,
    path: "/{accountId}/cards/{cardNumber}/closure.json",
    pattern: "/{accountId}/cards/{cardNumber}/closure",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `RequestEmailAddressChange` — `POST /{accountId}/users/{userId}/email_addresses.json`.
///
/// Sent once and never resent.
pub static REQUEST_EMAIL_ADDRESS_CHANGE: Route = Route {
    id: "RequestEmailAddressChange",
    service: "Users",
    method: Method::POST,
    path: "/{accountId}/users/{userId}/email_addresses.json",
    pattern: "/{accountId}/users/{userId}/email_addresses",
    account_scoped: true,
    resource_type: "email_address",
    params: &[RouteParam {
        name: "userId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `ResetJoinCode` — `DELETE /{accountId}/account/join_code.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static RESET_JOIN_CODE: Route = Route {
    id: "ResetJoinCode",
    service: "Account",
    method: Method::DELETE,
    path: "/{accountId}/account/join_code.json",
    pattern: "/{accountId}/account/join_code",
    account_scoped: true,
    resource_type: "join_code",
    params: &[],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `SearchCards` — `GET /{accountId}/search.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
///
/// Paginated: the answer is a page with `page` as its cursor, and the next one is read with `next_page`.
pub static SEARCH_CARDS: Route = Route {
    id: "SearchCards",
    service: "Search",
    method: Method::GET,
    path: "/{accountId}/search.json",
    pattern: "/{accountId}/search",
    account_scoped: true,
    resource_type: "card",
    params: &[],
    idempotent: true,
    readonly: true,
    pagination: Pagination::Link { page_param: "page" },
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `SelfAssignCard` — `POST /{accountId}/cards/{cardNumber}/self_assignment.json`.
///
/// Sent once and never resent.
pub static SELF_ASSIGN_CARD: Route = Route {
    id: "SelfAssignCard",
    service: "Cards",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/self_assignment.json",
    pattern: "/{accountId}/cards/{cardNumber}/self_assignment",
    account_scoped: true,
    resource_type: "assignment",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `TagCard` — `POST /{accountId}/cards/{cardNumber}/taggings.json`.
///
/// Sent once and never resent.
pub static TAG_CARD: Route = Route {
    id: "TagCard",
    service: "Cards",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/taggings.json",
    pattern: "/{accountId}/cards/{cardNumber}/taggings",
    account_scoped: true,
    resource_type: "tagging",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: false,
    readonly: false,
    pagination: Pagination::None,
    retry: None,
};

/// `TriageCard` — `POST /{accountId}/cards/{cardNumber}/triage.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503. Idempotent, so a resend is safe.
pub static TRIAGE_CARD: Route = Route {
    id: "TriageCard",
    service: "Cards",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/triage.json",
    pattern: "/{accountId}/cards/{cardNumber}/triage",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UnTriageCard` — `DELETE /{accountId}/cards/{cardNumber}/triage.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UN_TRIAGE_CARD: Route = Route {
    id: "UnTriageCard",
    service: "Cards",
    method: Method::DELETE,
    path: "/{accountId}/cards/{cardNumber}/triage.json",
    pattern: "/{accountId}/cards/{cardNumber}/triage",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UngoldCard` — `DELETE /{accountId}/cards/{cardNumber}/goldness.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UNGOLD_CARD: Route = Route {
    id: "UngoldCard",
    service: "Cards",
    method: Method::DELETE,
    path: "/{accountId}/cards/{cardNumber}/goldness.json",
    pattern: "/{accountId}/cards/{cardNumber}/goldness",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UnpinCard` — `DELETE /{accountId}/cards/{cardNumber}/pin.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UNPIN_CARD: Route = Route {
    id: "UnpinCard",
    service: "Cards",
    method: Method::DELETE,
    path: "/{accountId}/cards/{cardNumber}/pin.json",
    pattern: "/{accountId}/cards/{cardNumber}/pin",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UnpublishBoard` — `DELETE /{accountId}/boards/{boardId}/publication.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UNPUBLISH_BOARD: Route = Route {
    id: "UnpublishBoard",
    service: "Boards",
    method: Method::DELETE,
    path: "/{accountId}/boards/{boardId}/publication.json",
    pattern: "/{accountId}/boards/{boardId}/publication",
    account_scoped: true,
    resource_type: "board",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UnreadNotification` — `DELETE /{accountId}/notifications/{notificationId}/reading.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UNREAD_NOTIFICATION: Route = Route {
    id: "UnreadNotification",
    service: "Notifications",
    method: Method::DELETE,
    path: "/{accountId}/notifications/{notificationId}/reading.json",
    pattern: "/{accountId}/notifications/{notificationId}/reading",
    account_scoped: true,
    resource_type: "notification",
    params: &[RouteParam {
        name: "notificationId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UnregisterDevice` — `DELETE /{accountId}/devices/{deviceToken}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UNREGISTER_DEVICE: Route = Route {
    id: "UnregisterDevice",
    service: "Devices",
    method: Method::DELETE,
    path: "/{accountId}/devices/{deviceToken}",
    pattern: "/{accountId}/devices/{deviceToken}",
    account_scoped: true,
    resource_type: "device",
    params: &[RouteParam {
        name: "deviceToken",
        role: ParamRole::Recording,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UnwatchCard` — `DELETE /{accountId}/cards/{cardNumber}/watch.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UNWATCH_CARD: Route = Route {
    id: "UnwatchCard",
    service: "Cards",
    method: Method::DELETE,
    path: "/{accountId}/cards/{cardNumber}/watch.json",
    pattern: "/{accountId}/cards/{cardNumber}/watch",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateAccountEntropy` — `PUT /{accountId}/account/entropy.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_ACCOUNT_ENTROPY: Route = Route {
    id: "UpdateAccountEntropy",
    service: "Account",
    method: Method::PUT,
    path: "/{accountId}/account/entropy.json",
    pattern: "/{accountId}/account/entropy",
    account_scoped: true,
    resource_type: "account",
    params: &[],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateAccountSettings` — `PATCH /{accountId}/account/settings.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_ACCOUNT_SETTINGS: Route = Route {
    id: "UpdateAccountSettings",
    service: "Account",
    method: Method::PATCH,
    path: "/{accountId}/account/settings.json",
    pattern: "/{accountId}/account/settings",
    account_scoped: true,
    resource_type: "account_settings",
    params: &[],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateBoard` — `PATCH /{accountId}/boards/{boardId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_BOARD: Route = Route {
    id: "UpdateBoard",
    service: "Boards",
    method: Method::PATCH,
    path: "/{accountId}/boards/{boardId}",
    pattern: "/{accountId}/boards/{boardId}",
    account_scoped: true,
    resource_type: "board",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Recording,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateBoardEntropy` — `PUT /{accountId}/boards/{boardId}/entropy.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_BOARD_ENTROPY: Route = Route {
    id: "UpdateBoardEntropy",
    service: "Boards",
    method: Method::PUT,
    path: "/{accountId}/boards/{boardId}/entropy.json",
    pattern: "/{accountId}/boards/{boardId}/entropy",
    account_scoped: true,
    resource_type: "board",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateBoardInvolvement` — `PATCH /{accountId}/boards/{boardId}/involvement.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_BOARD_INVOLVEMENT: Route = Route {
    id: "UpdateBoardInvolvement",
    service: "Boards",
    method: Method::PATCH,
    path: "/{accountId}/boards/{boardId}/involvement.json",
    pattern: "/{accountId}/boards/{boardId}/involvement",
    account_scoped: true,
    resource_type: "board",
    params: &[RouteParam {
        name: "boardId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateCard` — `PATCH /{accountId}/cards/{cardNumber}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_CARD: Route = Route {
    id: "UpdateCard",
    service: "Cards",
    method: Method::PATCH,
    path: "/{accountId}/cards/{cardNumber}",
    pattern: "/{accountId}/cards/{cardNumber}",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Recording,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateColumn` — `PATCH /{accountId}/boards/{boardId}/columns/{columnId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_COLUMN: Route = Route {
    id: "UpdateColumn",
    service: "Columns",
    method: Method::PATCH,
    path: "/{accountId}/boards/{boardId}/columns/{columnId}",
    pattern: "/{accountId}/boards/{boardId}/columns/{columnId}",
    account_scoped: true,
    resource_type: "column",
    params: &[
        RouteParam {
            name: "boardId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
        RouteParam {
            name: "columnId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateComment` — `PATCH /{accountId}/cards/{cardNumber}/comments/{commentId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_COMMENT: Route = Route {
    id: "UpdateComment",
    service: "Comments",
    method: Method::PATCH,
    path: "/{accountId}/cards/{cardNumber}/comments/{commentId}",
    pattern: "/{accountId}/cards/{cardNumber}/comments/{commentId}",
    account_scoped: true,
    resource_type: "comment",
    params: &[
        RouteParam {
            name: "cardNumber",
            role: ParamRole::Parent,
            kind: ParamKind::Int32,
        },
        RouteParam {
            name: "commentId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateJoinCode` — `PATCH /{accountId}/account/join_code.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_JOIN_CODE: Route = Route {
    id: "UpdateJoinCode",
    service: "Account",
    method: Method::PATCH,
    path: "/{accountId}/account/join_code.json",
    pattern: "/{accountId}/account/join_code",
    account_scoped: true,
    resource_type: "join_code",
    params: &[],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateMyTimezone` — `PATCH /{accountId}/my/timezone.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_MY_TIMEZONE: Route = Route {
    id: "UpdateMyTimezone",
    service: "Identity",
    method: Method::PATCH,
    path: "/{accountId}/my/timezone.json",
    pattern: "/{accountId}/my/timezone",
    account_scoped: true,
    resource_type: "timezone",
    params: &[],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateNotificationSettings` — `PATCH /{accountId}/notifications/settings.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_NOTIFICATION_SETTINGS: Route = Route {
    id: "UpdateNotificationSettings",
    service: "Notifications",
    method: Method::PATCH,
    path: "/{accountId}/notifications/settings.json",
    pattern: "/{accountId}/notifications/settings",
    account_scoped: true,
    resource_type: "notification_settings",
    params: &[],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateStep` — `PATCH /{accountId}/cards/{cardNumber}/steps/{stepId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_STEP: Route = Route {
    id: "UpdateStep",
    service: "Steps",
    method: Method::PATCH,
    path: "/{accountId}/cards/{cardNumber}/steps/{stepId}",
    pattern: "/{accountId}/cards/{cardNumber}/steps/{stepId}",
    account_scoped: true,
    resource_type: "step",
    params: &[
        RouteParam {
            name: "cardNumber",
            role: ParamRole::Parent,
            kind: ParamKind::Int32,
        },
        RouteParam {
            name: "stepId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateUser` — `PATCH /{accountId}/users/{userId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_USER: Route = Route {
    id: "UpdateUser",
    service: "Users",
    method: Method::PATCH,
    path: "/{accountId}/users/{userId}",
    pattern: "/{accountId}/users/{userId}",
    account_scoped: true,
    resource_type: "user",
    params: &[RouteParam {
        name: "userId",
        role: ParamRole::Recording,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateUserRole` — `PATCH /{accountId}/users/{userId}/role.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_USER_ROLE: Route = Route {
    id: "UpdateUserRole",
    service: "Users",
    method: Method::PATCH,
    path: "/{accountId}/users/{userId}/role.json",
    pattern: "/{accountId}/users/{userId}/role",
    account_scoped: true,
    resource_type: "role",
    params: &[RouteParam {
        name: "userId",
        role: ParamRole::Parent,
        kind: ParamKind::String,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `UpdateWebhook` — `PATCH /{accountId}/boards/{boardId}/webhooks/{webhookId}`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503.
pub static UPDATE_WEBHOOK: Route = Route {
    id: "UpdateWebhook",
    service: "Webhooks",
    method: Method::PATCH,
    path: "/{accountId}/boards/{boardId}/webhooks/{webhookId}",
    pattern: "/{accountId}/boards/{boardId}/webhooks/{webhookId}",
    account_scoped: true,
    resource_type: "webhook",
    params: &[
        RouteParam {
            name: "boardId",
            role: ParamRole::Parent,
            kind: ParamKind::String,
        },
        RouteParam {
            name: "webhookId",
            role: ParamRole::Recording,
            kind: ParamKind::String,
        },
    ],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// `WatchCard` — `POST /{accountId}/cards/{cardNumber}/watch.json`.
///
/// Sent up to 3 times, backing off from 1000 ms, when the answer is 429, 500 or 503. Idempotent, so a resend is safe.
pub static WATCH_CARD: Route = Route {
    id: "WatchCard",
    service: "Cards",
    method: Method::POST,
    path: "/{accountId}/cards/{cardNumber}/watch.json",
    pattern: "/{accountId}/cards/{cardNumber}/watch",
    account_scoped: true,
    resource_type: "card",
    params: &[RouteParam {
        name: "cardNumber",
        role: ParamRole::Parent,
        kind: ParamKind::Int32,
    }],
    idempotent: true,
    readonly: false,
    pagination: Pagination::None,
    retry: Some(Retry {
        max: 3,
        base_delay_ms: 1000,
        retry_on: &[429, 500, 503],
    }),
};

/// Every route the SDK knows, one per operation, by operation id.
pub static ROUTES: &[&Route] = &[
    &ACTIVATE_WEBHOOK,
    &ASSIGN_CARD,
    &BULK_READ_NOTIFICATIONS,
    &CLOSE_CARD,
    &COMPLETE_JOIN,
    &COMPLETE_SIGNUP,
    &CONFIRM_EMAIL_ADDRESS_CHANGE,
    &CREATE_ACCESS_TOKEN,
    &CREATE_ACCOUNT_EXPORT,
    &CREATE_BOARD,
    &CREATE_CARD,
    &CREATE_CARD_REACTION,
    &CREATE_COLUMN,
    &CREATE_COMMENT,
    &CREATE_COMMENT_REACTION,
    &CREATE_DIRECT_UPLOAD,
    &CREATE_PUSH_SUBSCRIPTION,
    &CREATE_SESSION,
    &CREATE_STEP,
    &CREATE_USER_DATA_EXPORT,
    &CREATE_WEBHOOK,
    &DEACTIVATE_USER,
    &DELETE_ACCESS_TOKEN,
    &DELETE_BOARD,
    &DELETE_CARD,
    &DELETE_CARD_IMAGE,
    &DELETE_CARD_REACTION,
    &DELETE_COLUMN,
    &DELETE_COMMENT,
    &DELETE_COMMENT_REACTION,
    &DELETE_PUSH_SUBSCRIPTION,
    &DELETE_STEP,
    &DELETE_USER_AVATAR,
    &DELETE_WEBHOOK,
    &DESTROY_SESSION,
    &GET_ACCOUNT_EXPORT,
    &GET_ACCOUNT_SETTINGS,
    &GET_BOARD,
    &GET_CARD,
    &GET_COLUMN,
    &GET_COMMENT,
    &GET_JOIN_CODE,
    &GET_MY_IDENTITY,
    &GET_NOTIFICATION_SETTINGS,
    &GET_NOTIFICATION_TRAY,
    &GET_STEP,
    &GET_USER,
    &GET_USER_DATA_EXPORT,
    &GET_WEBHOOK,
    &GOLD_CARD,
    &LIST_ACCESS_TOKENS,
    &LIST_ACTIVITIES,
    &LIST_BOARD_ACCESSES,
    &LIST_BOARDS,
    &LIST_CARD_REACTIONS,
    &LIST_CARDS,
    &LIST_CLOSED_CARDS,
    &LIST_COLUMN_CARDS,
    &LIST_COLUMNS,
    &LIST_COMMENT_REACTIONS,
    &LIST_COMMENTS,
    &LIST_NOTIFICATIONS,
    &LIST_PINS,
    &LIST_POSTPONED_CARDS,
    &LIST_STEPS,
    &LIST_STREAM_CARDS,
    &LIST_TAGS,
    &LIST_USERS,
    &LIST_WEBHOOK_DELIVERIES,
    &LIST_WEBHOOKS,
    &MARK_CARD_READ,
    &MARK_CARD_UNREAD,
    &MOVE_CARD,
    &MOVE_COLUMN_LEFT,
    &MOVE_COLUMN_RIGHT,
    &PIN_CARD,
    &POSTPONE_CARD,
    &PUBLISH_BOARD,
    &PUBLISH_CARD,
    &READ_NOTIFICATION,
    &REDEEM_MAGIC_LINK,
    &REGISTER_DEVICE,
    &REOPEN_CARD,
    &REQUEST_EMAIL_ADDRESS_CHANGE,
    &RESET_JOIN_CODE,
    &SEARCH_CARDS,
    &SELF_ASSIGN_CARD,
    &TAG_CARD,
    &TRIAGE_CARD,
    &UN_TRIAGE_CARD,
    &UNGOLD_CARD,
    &UNPIN_CARD,
    &UNPUBLISH_BOARD,
    &UNREAD_NOTIFICATION,
    &UNREGISTER_DEVICE,
    &UNWATCH_CARD,
    &UPDATE_ACCOUNT_ENTROPY,
    &UPDATE_ACCOUNT_SETTINGS,
    &UPDATE_BOARD,
    &UPDATE_BOARD_ENTROPY,
    &UPDATE_BOARD_INVOLVEMENT,
    &UPDATE_CARD,
    &UPDATE_COLUMN,
    &UPDATE_COMMENT,
    &UPDATE_JOIN_CODE,
    &UPDATE_MY_TIMEZONE,
    &UPDATE_NOTIFICATION_SETTINGS,
    &UPDATE_STEP,
    &UPDATE_USER,
    &UPDATE_USER_ROLE,
    &UPDATE_WEBHOOK,
    &WATCH_CARD,
];